home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / core / Container.as < prev    next >
Encoding:
Text File  |  2010-05-14  |  87.9 KB  |  2,558 lines
  1. package mx.core
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.display.InteractiveObject;
  6.    import flash.display.Shape;
  7.    import flash.display.Sprite;
  8.    import flash.events.Event;
  9.    import flash.events.KeyboardEvent;
  10.    import flash.events.MouseEvent;
  11.    import flash.geom.Point;
  12.    import flash.geom.Rectangle;
  13.    import flash.system.ApplicationDomain;
  14.    import flash.text.TextField;
  15.    import flash.ui.Keyboard;
  16.    import mx.binding.BindingManager;
  17.    import mx.controls.Button;
  18.    import mx.controls.HScrollBar;
  19.    import mx.controls.VScrollBar;
  20.    import mx.controls.listClasses.IListItemRenderer;
  21.    import mx.controls.scrollClasses.ScrollBar;
  22.    import mx.events.ChildExistenceChangedEvent;
  23.    import mx.events.FlexEvent;
  24.    import mx.events.IndexChangedEvent;
  25.    import mx.events.ScrollEvent;
  26.    import mx.events.ScrollEventDetail;
  27.    import mx.events.ScrollEventDirection;
  28.    import mx.graphics.RoundedRectangle;
  29.    import mx.managers.IFocusManager;
  30.    import mx.managers.IFocusManagerContainer;
  31.    import mx.managers.ILayoutManagerClient;
  32.    import mx.managers.ISystemManager;
  33.    import mx.resources.ResourceBundle;
  34.    import mx.skins.RectangularBorder;
  35.    import mx.styles.CSSStyleDeclaration;
  36.    import mx.styles.ISimpleStyleClient;
  37.    import mx.styles.IStyleClient;
  38.    import mx.styles.StyleManager;
  39.    import mx.styles.StyleProtoChain;
  40.    
  41.    use namespace mx_internal;
  42.    
  43.    public class Container extends UIComponent implements IContainer, IDataRenderer, IFocusManagerContainer, IListItemRenderer, IRawChildrenContainer
  44.    {
  45.       private static var resourceMultipleChildSets_ClassAndInstance:String;
  46.       
  47.       private static var resourceMultipleChildSets_ClassAndSubclass:String;
  48.       
  49.       private static var resourceScrollDirection:String;
  50.       
  51.       mx_internal static const VERSION:String = "2.0.1.0";
  52.       
  53.       private static const MULTIPLE_PROPERTIES:String = "<MULTIPLE>";
  54.       
  55.       private static var packageResources:ResourceBundle = ResourceBundle.getResourceBundle("core",ApplicationDomain.currentDomain);
  56.       
  57.       loadResources();
  58.       
  59.       private var _horizontalLineScrollSize:Number = 5;
  60.       
  61.       mx_internal var border:IFlexDisplayObject;
  62.       
  63.       private var _viewMetricsAndPadding:EdgeMetrics;
  64.       
  65.       private var scrollableWidth:Number = 0;
  66.       
  67.       private var _rawChildren:ContainerRawChildrenList;
  68.       
  69.       private var _data:Object;
  70.       
  71.       private var _viewMetrics:EdgeMetrics;
  72.       
  73.       private var changedStyles:String = null;
  74.       
  75.       private var _verticalPageScrollSize:Number = 0;
  76.       
  77.       private var mouseEventReferenceCount:int = 0;
  78.       
  79.       protected var whiteBox:Shape;
  80.       
  81.       private var _verticalScrollBar:ScrollBar;
  82.       
  83.       private var _horizontalPageScrollSize:Number = 0;
  84.       
  85.       private var _clipContent:Boolean = true;
  86.       
  87.       private var _icon:Class = null;
  88.       
  89.       mx_internal var doingLayout:Boolean = false;
  90.       
  91.       private var _createdComponents:Array;
  92.       
  93.       private var _firstChildIndex:int = 0;
  94.       
  95.       private var scrollableHeight:Number = 0;
  96.       
  97.       mx_internal var _numChildren:int = 0;
  98.       
  99.       private var recursionFlag:Boolean = true;
  100.       
  101.       private var forceLayout:Boolean = false;
  102.       
  103.       mx_internal var blocker:Sprite;
  104.       
  105.       private var _label:String = "";
  106.       
  107.       private var _numChildrenCreated:int = -1;
  108.       
  109.       protected var actualCreationPolicy:String;
  110.       
  111.       private var _childRepeaters:Array;
  112.       
  113.       private var _childDescriptors:Array;
  114.       
  115.       private var scrollPropertiesChanged:Boolean = false;
  116.       
  117.       private var scrollPositionChanged:Boolean = true;
  118.       
  119.       private var _focusPane:Sprite;
  120.       
  121.       private var _defaultButton:IFlexDisplayObject;
  122.       
  123.       private var _forceClippingCount:int;
  124.       
  125.       mx_internal var creatingContentPane:Boolean = false;
  126.       
  127.       private var _creationPolicy:String;
  128.       
  129.       private var _creationIndex:int = -1;
  130.       
  131.       private var _verticalScrollPosition:Number = 0;
  132.       
  133.       private var _autoLayout:Boolean = true;
  134.       
  135.       private var _horizontalScrollBar:ScrollBar;
  136.       
  137.       private var viewableHeight:Number = 0;
  138.       
  139.       private var viewableWidth:Number = 0;
  140.       
  141.       mx_internal var contentPane:Sprite = null;
  142.       
  143.       private var numChildrenBefore:int;
  144.       
  145.       private var _verticalLineScrollSize:Number = 5;
  146.       
  147.       private var _horizontalScrollPosition:Number = 0;
  148.       
  149.       mx_internal var _horizontalScrollPolicy:String = "auto";
  150.       
  151.       private var verticalScrollPositionPending:Number;
  152.       
  153.       mx_internal var _verticalScrollPolicy:String = "auto";
  154.       
  155.       private var horizontalScrollPositionPending:Number;
  156.       
  157.       public function Container()
  158.       {
  159.          recursionFlag = true;
  160.          forceLayout = false;
  161.          mx_internal::doingLayout = false;
  162.          changedStyles = null;
  163.          mx_internal::creatingContentPane = false;
  164.          mx_internal::contentPane = null;
  165.          scrollPropertiesChanged = false;
  166.          scrollPositionChanged = true;
  167.          scrollableWidth = 0;
  168.          scrollableHeight = 0;
  169.          viewableWidth = 0;
  170.          viewableHeight = 0;
  171.          mouseEventReferenceCount = 0;
  172.          mx_internal::_numChildren = 0;
  173.          _autoLayout = true;
  174.          _clipContent = true;
  175.          _creationIndex = -1;
  176.          _firstChildIndex = 0;
  177.          _horizontalLineScrollSize = 5;
  178.          _horizontalPageScrollSize = 0;
  179.          _horizontalScrollPosition = 0;
  180.          mx_internal::_horizontalScrollPolicy = ScrollPolicy.AUTO;
  181.          _icon = null;
  182.          _label = "";
  183.          _numChildrenCreated = -1;
  184.          _verticalLineScrollSize = 5;
  185.          _verticalPageScrollSize = 0;
  186.          _verticalScrollPosition = 0;
  187.          mx_internal::_verticalScrollPolicy = ScrollPolicy.AUTO;
  188.          super();
  189.          tabChildren = true;
  190.          tabEnabled = false;
  191.          showInAutomationHierarchy = false;
  192.       }
  193.       
  194.       private static function loadResources() : void
  195.       {
  196.          resourceScrollDirection = packageResources.getString("scrollDirection");
  197.          resourceMultipleChildSets_ClassAndInstance = packageResources.getString("multipleChildSets_ClassAndInstance");
  198.          resourceMultipleChildSets_ClassAndSubclass = packageResources.getString("multipleChildSets_ClassAndSubclass");
  199.       }
  200.       
  201.       mx_internal static function checkFocus(param1:InteractiveObject, param2:InteractiveObject) : void
  202.       {
  203.          var _loc3_:InteractiveObject = null;
  204.          var _loc4_:InteractiveObject = null;
  205.          var _loc5_:IUIComponent = null;
  206.          var _loc6_:IFocusManager = null;
  207.          var _loc7_:Button = null;
  208.          _loc3_ = param2;
  209.          _loc4_ = param2;
  210.          _loc5_ = null;
  211.          if(param2 != null && param1 == param2)
  212.          {
  213.             return;
  214.          }
  215.          while(_loc4_)
  216.          {
  217.             if(_loc4_.parent)
  218.             {
  219.                _loc3_ = _loc4_.parent;
  220.             }
  221.             else
  222.             {
  223.                _loc3_ = null;
  224.             }
  225.             if(_loc4_ is IUIComponent)
  226.             {
  227.                _loc5_ = IUIComponent(_loc4_);
  228.             }
  229.             _loc4_ = _loc3_;
  230.             if((_loc4_) && _loc4_ is Container && Boolean(Container(_loc4_).defaultButton))
  231.             {
  232.                break;
  233.             }
  234.          }
  235.          if(ContainerGlobals.focusedContainer != _loc4_)
  236.          {
  237.             if(!_loc4_)
  238.             {
  239.                _loc4_ = InteractiveObject(_loc5_);
  240.             }
  241.             if(Boolean(_loc4_) && _loc4_ is Container)
  242.             {
  243.                _loc6_ = UIComponent(_loc4_).focusManager;
  244.                _loc7_ = Container(_loc4_).defaultButton as Button;
  245.                if(_loc7_)
  246.                {
  247.                   ContainerGlobals.focusedContainer = Container(_loc4_);
  248.                   _loc6_.defaultButton = _loc7_;
  249.                }
  250.                else
  251.                {
  252.                   ContainerGlobals.focusedContainer = Container(_loc4_);
  253.                   _loc6_.defaultButton = null;
  254.                }
  255.             }
  256.          }
  257.       }
  258.       
  259.       mx_internal function get firstChildIndex() : int
  260.       {
  261.          return _firstChildIndex;
  262.       }
  263.       
  264.       mx_internal function rawChildren_getObjectsUnderPoint(param1:Point) : Array
  265.       {
  266.          return super.getObjectsUnderPoint(param1);
  267.       }
  268.       
  269.       protected function scrollChildren() : void
  270.       {
  271.          var _loc1_:EdgeMetrics = null;
  272.          var _loc2_:Number = NaN;
  273.          var _loc3_:Number = NaN;
  274.          var _loc4_:Number = NaN;
  275.          var _loc5_:Number = NaN;
  276.          var _loc6_:Rectangle = null;
  277.          if(!mx_internal::contentPane)
  278.          {
  279.             return;
  280.          }
  281.          _loc1_ = viewMetrics;
  282.          _loc2_ = 0;
  283.          _loc3_ = 0;
  284.          _loc4_ = unscaledWidth - _loc1_.left - _loc1_.right;
  285.          _loc5_ = unscaledHeight - _loc1_.top - _loc1_.bottom;
  286.          if(_clipContent)
  287.          {
  288.             _loc2_ += _horizontalScrollPosition;
  289.             if(horizontalScrollBar)
  290.             {
  291.                _loc4_ = viewableWidth;
  292.             }
  293.             _loc3_ += _verticalScrollPosition;
  294.             if(verticalScrollBar)
  295.             {
  296.                _loc5_ = viewableHeight;
  297.             }
  298.          }
  299.          else
  300.          {
  301.             _loc4_ = scrollableWidth;
  302.             _loc5_ = scrollableHeight;
  303.          }
  304.          _loc6_ = mx_internal::getScrollableRect();
  305.          if(_loc2_ == 0 && _loc3_ == 0 && _loc4_ >= _loc6_.right && _loc5_ >= _loc6_.bottom && _loc6_.left >= 0 && _loc6_.top >= 0 && _forceClippingCount <= 0)
  306.          {
  307.             mx_internal::contentPane.scrollRect = null;
  308.             mx_internal::contentPane.opaqueBackground = null;
  309.             mx_internal::contentPane.cacheAsBitmap = false;
  310.          }
  311.          else
  312.          {
  313.             mx_internal::contentPane.scrollRect = new Rectangle(_loc2_,_loc3_,_loc4_,_loc5_);
  314.          }
  315.          if(focusPane)
  316.          {
  317.             focusPane.scrollRect = mx_internal::contentPane.scrollRect;
  318.          }
  319.          if(mx_internal::border && mx_internal::border is RectangularBorder && RectangularBorder(mx_internal::border).mx_internal::hasBackgroundImage)
  320.          {
  321.             RectangularBorder(mx_internal::border).mx_internal::adjustBackgroundImage();
  322.          }
  323.       }
  324.       
  325.       mx_internal function get createdComponents() : Array
  326.       {
  327.          return _createdComponents;
  328.       }
  329.       
  330.       public function get childDescriptors() : Array
  331.       {
  332.          return _childDescriptors;
  333.       }
  334.       
  335.       [Bindable("viewChanged")]
  336.       [Bindable("scroll")]
  337.       public function get verticalScrollPosition() : Number
  338.       {
  339.          if(!isNaN(verticalScrollPositionPending))
  340.          {
  341.             return verticalScrollPositionPending;
  342.          }
  343.          return _verticalScrollPosition;
  344.       }
  345.       
  346.       mx_internal function set createdComponents(param1:Array) : void
  347.       {
  348.          _createdComponents = param1;
  349.       }
  350.       
  351.       mx_internal function get childRepeaters() : Array
  352.       {
  353.          return _childRepeaters;
  354.       }
  355.       
  356.       [Bindable("viewChanged")]
  357.       [Bindable("scroll")]
  358.       public function get horizontalScrollPosition() : Number
  359.       {
  360.          if(!isNaN(horizontalScrollPositionPending))
  361.          {
  362.             return horizontalScrollPositionPending;
  363.          }
  364.          return _horizontalScrollPosition;
  365.       }
  366.       
  367.       override public function get focusPane() : Sprite
  368.       {
  369.          return _focusPane;
  370.       }
  371.       
  372.       private function createOrDestroyScrollbars(param1:Boolean, param2:Boolean, param3:Boolean) : Boolean
  373.       {
  374.          var _loc4_:Boolean = false;
  375.          var _loc5_:IFocusManager = null;
  376.          var _loc6_:String = null;
  377.          var _loc7_:String = null;
  378.          var _loc8_:Graphics = null;
  379.          _loc4_ = false;
  380.          if(param1 || param2 || param3)
  381.          {
  382.             mx_internal::createContentPane();
  383.          }
  384.          if(param1)
  385.          {
  386.             if(!horizontalScrollBar)
  387.             {
  388.                horizontalScrollBar = new HScrollBar();
  389.                horizontalScrollBar.name = "horizontalScrollBar";
  390.                _loc6_ = getStyle("horizontalScrollBarStyleName");
  391.                if((Boolean(_loc6_)) && horizontalScrollBar is ISimpleStyleClient)
  392.                {
  393.                   ISimpleStyleClient(horizontalScrollBar).styleName = _loc6_;
  394.                }
  395.                rawChildren.addChild(DisplayObject(horizontalScrollBar));
  396.                horizontalScrollBar.lineScrollSize = horizontalLineScrollSize;
  397.                horizontalScrollBar.pageScrollSize = horizontalPageScrollSize;
  398.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,horizontalScrollBar_scrollHandler);
  399.                horizontalScrollBar.enabled = enabled;
  400.                if(horizontalScrollBar is IInvalidating)
  401.                {
  402.                   IInvalidating(horizontalScrollBar).validateNow();
  403.                }
  404.                invalidateDisplayList();
  405.                mx_internal::invalidateViewMetricsAndPadding();
  406.                _loc4_ = true;
  407.                if(!verticalScrollBar)
  408.                {
  409.                   addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  410.                }
  411.             }
  412.          }
  413.          else if(horizontalScrollBar)
  414.          {
  415.             horizontalScrollBar.removeEventListener(ScrollEvent.SCROLL,horizontalScrollBar_scrollHandler);
  416.             rawChildren.removeChild(DisplayObject(horizontalScrollBar));
  417.             horizontalScrollBar = null;
  418.             viewableWidth = scrollableWidth = 0;
  419.             if(_horizontalScrollPosition != 0)
  420.             {
  421.                _horizontalScrollPosition = 0;
  422.                scrollPositionChanged = true;
  423.             }
  424.             invalidateDisplayList();
  425.             mx_internal::invalidateViewMetricsAndPadding();
  426.             _loc4_ = true;
  427.             _loc5_ = focusManager;
  428.             if(!verticalScrollBar && (!_loc5_ || _loc5_.getFocus() != this))
  429.             {
  430.                removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  431.             }
  432.          }
  433.          if(param2)
  434.          {
  435.             if(!verticalScrollBar)
  436.             {
  437.                verticalScrollBar = new VScrollBar();
  438.                verticalScrollBar.name = "verticalScrollBar";
  439.                _loc7_ = getStyle("verticalScrollBarStyleName");
  440.                if((Boolean(_loc7_)) && verticalScrollBar is ISimpleStyleClient)
  441.                {
  442.                   ISimpleStyleClient(verticalScrollBar).styleName = _loc7_;
  443.                }
  444.                rawChildren.addChild(DisplayObject(verticalScrollBar));
  445.                verticalScrollBar.lineScrollSize = verticalLineScrollSize;
  446.                verticalScrollBar.pageScrollSize = verticalPageScrollSize;
  447.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,verticalScrollBar_scrollHandler);
  448.                verticalScrollBar.enabled = enabled;
  449.                if(verticalScrollBar is IInvalidating)
  450.                {
  451.                   IInvalidating(verticalScrollBar).validateNow();
  452.                }
  453.                invalidateDisplayList();
  454.                mx_internal::invalidateViewMetricsAndPadding();
  455.                _loc4_ = true;
  456.                if(!horizontalScrollBar)
  457.                {
  458.                   addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  459.                }
  460.                addEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  461.             }
  462.          }
  463.          else if(verticalScrollBar)
  464.          {
  465.             verticalScrollBar.removeEventListener(ScrollEvent.SCROLL,verticalScrollBar_scrollHandler);
  466.             rawChildren.removeChild(DisplayObject(verticalScrollBar));
  467.             verticalScrollBar = null;
  468.             viewableHeight = scrollableHeight = 0;
  469.             if(_verticalScrollPosition != 0)
  470.             {
  471.                _verticalScrollPosition = 0;
  472.                scrollPositionChanged = true;
  473.             }
  474.             invalidateDisplayList();
  475.             mx_internal::invalidateViewMetricsAndPadding();
  476.             _loc4_ = true;
  477.             _loc5_ = focusManager;
  478.             if(!horizontalScrollBar && (!_loc5_ || _loc5_.getFocus() != this))
  479.             {
  480.                removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  481.             }
  482.             removeEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  483.          }
  484.          if(Boolean(horizontalScrollBar) && Boolean(verticalScrollBar))
  485.          {
  486.             if(!whiteBox)
  487.             {
  488.                whiteBox = new FlexShape();
  489.                whiteBox.name = "whiteBox";
  490.                _loc8_ = whiteBox.graphics;
  491.                _loc8_.beginFill(16777215);
  492.                _loc8_.drawRect(0,0,verticalScrollBar.minWidth,horizontalScrollBar.minHeight);
  493.                _loc8_.endFill();
  494.                rawChildren.addChild(whiteBox);
  495.             }
  496.          }
  497.          else if(whiteBox)
  498.          {
  499.             rawChildren.removeChild(whiteBox);
  500.             whiteBox = null;
  501.          }
  502.          return _loc4_;
  503.       }
  504.       
  505.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  506.       {
  507.          var _loc2_:Object = null;
  508.          var _loc3_:String = null;
  509.          var _loc4_:Number = NaN;
  510.          _loc2_ = getFocus();
  511.          if(_loc2_ is TextField)
  512.          {
  513.             return;
  514.          }
  515.          if(verticalScrollBar)
  516.          {
  517.             _loc3_ = ScrollEventDirection.VERTICAL;
  518.             _loc4_ = verticalScrollPosition;
  519.             switch(param1.keyCode)
  520.             {
  521.                case Keyboard.DOWN:
  522.                   verticalScrollPosition += verticalLineScrollSize;
  523.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.LINE_DOWN);
  524.                   param1.stopPropagation();
  525.                   break;
  526.                case Keyboard.UP:
  527.                   verticalScrollPosition -= verticalLineScrollSize;
  528.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.LINE_UP);
  529.                   param1.stopPropagation();
  530.                   break;
  531.                case Keyboard.PAGE_UP:
  532.                   verticalScrollPosition -= verticalPageScrollSize;
  533.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.PAGE_UP);
  534.                   param1.stopPropagation();
  535.                   break;
  536.                case Keyboard.PAGE_DOWN:
  537.                   verticalScrollPosition += verticalPageScrollSize;
  538.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.PAGE_DOWN);
  539.                   param1.stopPropagation();
  540.                   break;
  541.                case Keyboard.HOME:
  542.                   verticalScrollPosition = verticalScrollBar.minScrollPosition;
  543.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.AT_TOP);
  544.                   param1.stopPropagation();
  545.                   break;
  546.                case Keyboard.END:
  547.                   verticalScrollPosition = verticalScrollBar.maxScrollPosition;
  548.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.AT_BOTTOM);
  549.                   param1.stopPropagation();
  550.             }
  551.          }
  552.          if(horizontalScrollBar)
  553.          {
  554.             _loc3_ = ScrollEventDirection.HORIZONTAL;
  555.             _loc4_ = horizontalScrollPosition;
  556.             switch(param1.keyCode)
  557.             {
  558.                case Keyboard.LEFT:
  559.                   horizontalScrollPosition -= horizontalLineScrollSize;
  560.                   dispatchScrollEvent(_loc3_,_loc4_,horizontalScrollPosition,ScrollEventDetail.LINE_LEFT);
  561.                   param1.stopPropagation();
  562.                   break;
  563.                case Keyboard.RIGHT:
  564.                   horizontalScrollPosition += horizontalLineScrollSize;
  565.                   dispatchScrollEvent(_loc3_,_loc4_,horizontalScrollPosition,ScrollEventDetail.LINE_RIGHT);
  566.                   param1.stopPropagation();
  567.             }
  568.          }
  569.       }
  570.       
  571.       protected function createBorder() : void
  572.       {
  573.          var _loc1_:Class = null;
  574.          if(!mx_internal::border && isBorderNeeded())
  575.          {
  576.             _loc1_ = getStyle("borderSkin");
  577.             mx_internal::border = new _loc1_();
  578.             mx_internal::border.name = "border";
  579.             if(mx_internal::border is IUIComponent)
  580.             {
  581.                IUIComponent(mx_internal::border).enabled = enabled;
  582.             }
  583.             if(mx_internal::border is ISimpleStyleClient)
  584.             {
  585.                ISimpleStyleClient(mx_internal::border).styleName = this;
  586.             }
  587.             rawChildren.addChildAt(DisplayObject(mx_internal::border),0);
  588.             invalidateDisplayList();
  589.          }
  590.       }
  591.       
  592.       public function set verticalScrollPosition(param1:Number) : void
  593.       {
  594.          if(_verticalScrollPosition == param1)
  595.          {
  596.             return;
  597.          }
  598.          _verticalScrollPosition = param1;
  599.          scrollPositionChanged = true;
  600.          if(!initialized)
  601.          {
  602.             verticalScrollPositionPending = param1;
  603.          }
  604.          invalidateDisplayList();
  605.          dispatchEvent(new Event("viewChanged"));
  606.       }
  607.       
  608.       private function horizontalScrollBar_scrollHandler(param1:Event) : void
  609.       {
  610.          var _loc2_:Number = NaN;
  611.          if(param1 is ScrollEvent)
  612.          {
  613.             _loc2_ = horizontalScrollPosition;
  614.             horizontalScrollPosition = horizontalScrollBar.scrollPosition;
  615.             dispatchScrollEvent(ScrollEventDirection.HORIZONTAL,_loc2_,horizontalScrollPosition,ScrollEvent(param1).detail);
  616.          }
  617.       }
  618.       
  619.       [Bindable("iconChanged")]
  620.       public function get icon() : Class
  621.       {
  622.          return _icon;
  623.       }
  624.       
  625.       public function set horizontalScrollBar(param1:ScrollBar) : void
  626.       {
  627.          _horizontalScrollBar = param1;
  628.       }
  629.       
  630.       mx_internal function set childRepeaters(param1:Array) : void
  631.       {
  632.          _childRepeaters = param1;
  633.       }
  634.       
  635.       public function createComponentFromDescriptor(param1:ComponentDescriptor, param2:Boolean) : IFlexDisplayObject
  636.       {
  637.          var _loc3_:UIComponentDescriptor = null;
  638.          var _loc4_:Object = null;
  639.          var _loc5_:Class = null;
  640.          var _loc6_:IDeferredInstantiationUIComponent = null;
  641.          var _loc7_:String = null;
  642.          var _loc8_:Object = null;
  643.          var _loc9_:Array = null;
  644.          var _loc10_:IRepeaterClient = null;
  645.          var _loc11_:IStyleClient = null;
  646.          var _loc12_:String = null;
  647.          var _loc13_:String = null;
  648.          _loc3_ = UIComponentDescriptor(param1);
  649.          _loc4_ = _loc3_.properties;
  650.          if((numChildrenBefore != 0 || mx_internal::numChildrenCreated != -1) && _loc3_.mx_internal::instanceIndices == null && hasChildMatchingDescriptor(_loc3_))
  651.          {
  652.             return null;
  653.          }
  654.          UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = true;
  655.          _loc5_ = _loc3_.type;
  656.          _loc6_ = new _loc5_();
  657.          _loc6_.id = _loc3_.id;
  658.          if(Boolean(_loc6_.id) && _loc6_.id != "")
  659.          {
  660.             _loc6_.name = _loc6_.id;
  661.          }
  662.          _loc6_.descriptor = _loc3_;
  663.          if(Boolean(_loc4_.childDescriptors) && _loc6_ is Container)
  664.          {
  665.             Container(_loc6_)._childDescriptors = _loc4_.childDescriptors;
  666.             delete _loc4_.childDescriptors;
  667.          }
  668.          for(_loc7_ in _loc4_)
  669.          {
  670.             _loc6_[_loc7_] = _loc4_[_loc7_];
  671.          }
  672.          if(_loc6_ is Container)
  673.          {
  674.             Container(_loc6_).recursionFlag = param2;
  675.          }
  676.          if(_loc3_.mx_internal::instanceIndices)
  677.          {
  678.             if(_loc6_ is IRepeaterClient)
  679.             {
  680.                _loc10_ = IRepeaterClient(_loc6_);
  681.                _loc10_.instanceIndices = _loc3_.mx_internal::instanceIndices;
  682.                _loc10_.repeaters = _loc3_.mx_internal::repeaters;
  683.                _loc10_.repeaterIndices = _loc3_.mx_internal::repeaterIndices;
  684.             }
  685.          }
  686.          if(_loc6_ is IStyleClient)
  687.          {
  688.             _loc11_ = IStyleClient(_loc6_);
  689.             if(_loc3_.stylesFactory != null)
  690.             {
  691.                if(!_loc11_.styleDeclaration)
  692.                {
  693.                   _loc11_.styleDeclaration = new CSSStyleDeclaration();
  694.                }
  695.                _loc11_.styleDeclaration.factory = _loc3_.stylesFactory;
  696.             }
  697.          }
  698.          _loc8_ = _loc3_.events;
  699.          if(_loc8_)
  700.          {
  701.             for(_loc12_ in _loc8_)
  702.             {
  703.                _loc13_ = _loc8_[_loc12_];
  704.                _loc6_.addEventListener(_loc12_,_loc3_.document[_loc13_]);
  705.             }
  706.          }
  707.          _loc9_ = _loc3_.effects;
  708.          if(_loc9_)
  709.          {
  710.             _loc6_.registerEffects(_loc9_);
  711.          }
  712.          if(_loc6_ is IRepeaterClient)
  713.          {
  714.             IRepeaterClient(_loc6_).initializeRepeaterArrays(this);
  715.          }
  716.          _loc6_.createReferenceOnParentDocument(IFlexDisplayObject(_loc3_.document));
  717.          if(!_loc6_.document)
  718.          {
  719.             _loc6_.document = _loc3_.document;
  720.          }
  721.          if(_loc6_ is IRepeater)
  722.          {
  723.             if(!mx_internal::childRepeaters)
  724.             {
  725.                mx_internal::childRepeaters = [];
  726.             }
  727.             mx_internal::childRepeaters.push(_loc6_);
  728.             _loc6_.executeBindings();
  729.             IRepeater(_loc6_).initializeRepeater(this,param2);
  730.          }
  731.          else
  732.          {
  733.             addChild(DisplayObject(_loc6_));
  734.             _loc6_.executeBindings();
  735.             if(creationPolicy == ContainerCreationPolicy.QUEUED || creationPolicy == ContainerCreationPolicy.NONE)
  736.             {
  737.                _loc6_.addEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  738.             }
  739.          }
  740.          return _loc6_;
  741.       }
  742.       
  743.       mx_internal function get usePadding() : Boolean
  744.       {
  745.          return true;
  746.       }
  747.       
  748.       public function set horizontalScrollPosition(param1:Number) : void
  749.       {
  750.          if(_horizontalScrollPosition == param1)
  751.          {
  752.             return;
  753.          }
  754.          _horizontalScrollPosition = param1;
  755.          scrollPositionChanged = true;
  756.          if(!initialized)
  757.          {
  758.             horizontalScrollPositionPending = param1;
  759.          }
  760.          invalidateDisplayList();
  761.          dispatchEvent(new Event("viewChanged"));
  762.       }
  763.       
  764.       override public function set focusPane(param1:Sprite) : void
  765.       {
  766.          var _loc2_:Boolean = false;
  767.          var _loc3_:Boolean = false;
  768.          _loc2_ = Boolean(mx_internal::invalidateSizeFlag);
  769.          _loc3_ = Boolean(mx_internal::invalidateDisplayListFlag);
  770.          mx_internal::invalidateSizeFlag = true;
  771.          mx_internal::invalidateDisplayListFlag = true;
  772.          if(param1)
  773.          {
  774.             rawChildren.addChild(param1);
  775.             param1.x = 0;
  776.             param1.y = 0;
  777.             param1.scrollRect = null;
  778.             _focusPane = param1;
  779.          }
  780.          else
  781.          {
  782.             rawChildren.removeChild(_focusPane);
  783.             _focusPane = null;
  784.          }
  785.          if(Boolean(param1) && Boolean(mx_internal::contentPane))
  786.          {
  787.             param1.x = mx_internal::contentPane.x;
  788.             param1.y = mx_internal::contentPane.y;
  789.             param1.scrollRect = mx_internal::contentPane.scrollRect;
  790.          }
  791.          mx_internal::invalidateSizeFlag = _loc2_;
  792.          mx_internal::invalidateDisplayListFlag = _loc3_;
  793.       }
  794.       
  795.       [Bindable("horizontalScrollPolicyChanged")]
  796.       public function get horizontalScrollPolicy() : String
  797.       {
  798.          return mx_internal::_horizontalScrollPolicy;
  799.       }
  800.       
  801.       [Bindable("horizontalLineScrollSizeChanged")]
  802.       public function get horizontalLineScrollSize() : Number
  803.       {
  804.          return _horizontalLineScrollSize;
  805.       }
  806.       
  807.       private function updateBackgroundImageRect() : void
  808.       {
  809.          var _loc1_:RectangularBorder = null;
  810.          var _loc2_:EdgeMetrics = null;
  811.          var _loc3_:Number = NaN;
  812.          var _loc4_:Number = NaN;
  813.          _loc1_ = mx_internal::border as RectangularBorder;
  814.          if(!_loc1_)
  815.          {
  816.             return;
  817.          }
  818.          if(viewableWidth == 0 && viewableHeight == 0)
  819.          {
  820.             _loc1_.mx_internal::backgroundImageRect = null;
  821.             return;
  822.          }
  823.          _loc2_ = viewMetrics;
  824.          _loc3_ = !!viewableWidth ? viewableWidth : unscaledWidth - _loc2_.left - _loc2_.right;
  825.          _loc4_ = !!viewableHeight ? viewableHeight : unscaledHeight - _loc2_.top - _loc2_.bottom;
  826.          if(getStyle("backgroundAttachment") == "fixed")
  827.          {
  828.             _loc1_.mx_internal::backgroundImageRect = new Rectangle(_loc2_.left,_loc2_.top,_loc3_,_loc4_);
  829.          }
  830.          else
  831.          {
  832.             _loc1_.mx_internal::backgroundImageRect = new Rectangle(_loc2_.left,_loc2_.top,Math.max(scrollableWidth,_loc3_),Math.max(scrollableHeight,_loc4_));
  833.          }
  834.       }
  835.       
  836.       mx_internal function invalidateViewMetricsAndPadding() : void
  837.       {
  838.          _viewMetricsAndPadding = null;
  839.       }
  840.       
  841.       [Bindable("verticalLineScrollSizeChanged")]
  842.       public function get verticalLineScrollSize() : Number
  843.       {
  844.          return _verticalLineScrollSize;
  845.       }
  846.       
  847.       private function mouseWheelHandler(param1:MouseEvent) : void
  848.       {
  849.          var _loc2_:int = 0;
  850.          var _loc3_:int = 0;
  851.          var _loc4_:Number = NaN;
  852.          var _loc5_:Number = NaN;
  853.          if(verticalScrollBar)
  854.          {
  855.             param1.stopPropagation();
  856.             _loc2_ = param1.delta <= 0 ? 1 : -1;
  857.             _loc3_ = !!verticalScrollBar ? int(verticalScrollBar.lineScrollSize) : 1;
  858.             _loc4_ = Math.max(Math.abs(param1.delta),_loc3_);
  859.             _loc5_ = verticalScrollPosition;
  860.             verticalScrollPosition += 3 * _loc4_ * _loc2_;
  861.             dispatchScrollEvent(ScrollEventDirection.VERTICAL,_loc5_,verticalScrollPosition,param1.delta <= 0 ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_DOWN);
  862.          }
  863.       }
  864.       
  865.       mx_internal function createContentPane() : void
  866.       {
  867.          var _loc1_:int = 0;
  868.          var _loc2_:Sprite = null;
  869.          var _loc3_:int = 0;
  870.          var _loc4_:int = 0;
  871.          var _loc5_:IUIComponent = null;
  872.          if(mx_internal::contentPane)
  873.          {
  874.             return;
  875.          }
  876.          mx_internal::creatingContentPane = true;
  877.          _loc1_ = numChildren;
  878.          _loc2_ = new FlexSprite();
  879.          _loc2_.name = "contentPane";
  880.          _loc2_.tabChildren = true;
  881.          if(mx_internal::border)
  882.          {
  883.             _loc3_ = rawChildren.getChildIndex(DisplayObject(mx_internal::border)) + 1;
  884.             if(mx_internal::border is RectangularBorder && RectangularBorder(mx_internal::border).mx_internal::hasBackgroundImage)
  885.             {
  886.                _loc3_++;
  887.             }
  888.          }
  889.          else
  890.          {
  891.             _loc3_ = 0;
  892.          }
  893.          rawChildren.addChildAt(_loc2_,_loc3_);
  894.          _loc4_ = 0;
  895.          while(_loc4_ < _loc1_)
  896.          {
  897.             _loc5_ = IUIComponent(super.getChildAt(_firstChildIndex));
  898.             _loc2_.addChild(DisplayObject(_loc5_));
  899.             _loc5_.parentChanged(_loc2_);
  900.             --mx_internal::_numChildren;
  901.             _loc4_++;
  902.          }
  903.          mx_internal::contentPane = _loc2_;
  904.          mx_internal::creatingContentPane = false;
  905.          mx_internal::contentPane.visible = true;
  906.       }
  907.       
  908.       public function get creationPolicy() : String
  909.       {
  910.          return _creationPolicy;
  911.       }
  912.       
  913.       public function get defaultButton() : IFlexDisplayObject
  914.       {
  915.          return _defaultButton;
  916.       }
  917.       
  918.       [Bindable("verticalScrollPolicyChanged")]
  919.       public function get verticalScrollPolicy() : String
  920.       {
  921.          return mx_internal::_verticalScrollPolicy;
  922.       }
  923.       
  924.       private function verticalScrollBar_scrollHandler(param1:Event) : void
  925.       {
  926.          var _loc2_:Number = NaN;
  927.          if(param1 is ScrollEvent)
  928.          {
  929.             _loc2_ = verticalScrollPosition;
  930.             verticalScrollPosition = verticalScrollBar.scrollPosition;
  931.             dispatchScrollEvent(ScrollEventDirection.VERTICAL,_loc2_,verticalScrollPosition,ScrollEvent(param1).detail);
  932.          }
  933.       }
  934.       
  935.       mx_internal function rawChildren_removeChild(param1:DisplayObject) : DisplayObject
  936.       {
  937.          var _loc2_:int = 0;
  938.          _loc2_ = mx_internal::rawChildren_getChildIndex(param1);
  939.          return mx_internal::rawChildren_removeChildAt(_loc2_);
  940.       }
  941.       
  942.       final mx_internal function get $numChildren() : int
  943.       {
  944.          return super.numChildren;
  945.       }
  946.       
  947.       override public function addChild(param1:DisplayObject) : DisplayObject
  948.       {
  949.          return addChildAt(param1,numChildren);
  950.       }
  951.       
  952.       override public function getChildIndex(param1:DisplayObject) : int
  953.       {
  954.          var _loc2_:int = 0;
  955.          if(mx_internal::contentPane)
  956.          {
  957.             return mx_internal::contentPane.getChildIndex(param1);
  958.          }
  959.          return int(super.getChildIndex(param1) - _firstChildIndex);
  960.       }
  961.       
  962.       public function set icon(param1:Class) : void
  963.       {
  964.          _icon = param1;
  965.          dispatchEvent(new Event("iconChanged"));
  966.       }
  967.       
  968.       mx_internal function rawChildren_contains(param1:DisplayObject) : Boolean
  969.       {
  970.          return super.contains(param1);
  971.       }
  972.       
  973.       override public function executeBindings(param1:Boolean = false) : void
  974.       {
  975.          var _loc2_:Object = null;
  976.          _loc2_ = Boolean(descriptor) && Boolean(descriptor.document) ? descriptor.document : parentDocument;
  977.          BindingManager.executeBindings(_loc2_,id,this);
  978.          if(param1)
  979.          {
  980.             executeChildBindings(param1);
  981.          }
  982.       }
  983.       
  984.       mx_internal function rawChildren_getChildIndex(param1:DisplayObject) : int
  985.       {
  986.          return super.getChildIndex(param1);
  987.       }
  988.       
  989.       public function set verticalLineScrollSize(param1:Number) : void
  990.       {
  991.          scrollPropertiesChanged = true;
  992.          _verticalLineScrollSize = param1;
  993.          invalidateDisplayList();
  994.          dispatchEvent(new Event("verticalLineScrollSizeChanged"));
  995.       }
  996.       
  997.       mx_internal function getScrollableRect() : Rectangle
  998.       {
  999.          var _loc1_:Number = NaN;
  1000.          var _loc2_:Number = NaN;
  1001.          var _loc3_:Number = NaN;
  1002.          var _loc4_:Number = NaN;
  1003.          var _loc5_:int = 0;
  1004.          var _loc6_:int = 0;
  1005.          var _loc7_:EdgeMetrics = null;
  1006.          var _loc8_:Rectangle = null;
  1007.          var _loc9_:DisplayObject = null;
  1008.          _loc1_ = 0;
  1009.          _loc2_ = 0;
  1010.          _loc3_ = 0;
  1011.          _loc4_ = 0;
  1012.          _loc5_ = numChildren;
  1013.          _loc6_ = 0;
  1014.          while(_loc6_ < _loc5_)
  1015.          {
  1016.             _loc9_ = getChildAt(_loc6_);
  1017.             if(!(_loc9_ is IUIComponent && !IUIComponent(_loc9_).includeInLayout))
  1018.             {
  1019.                _loc1_ = Math.min(_loc1_,_loc9_.x);
  1020.                _loc2_ = Math.min(_loc2_,_loc9_.y);
  1021.                if(!isNaN(_loc9_.width))
  1022.                {
  1023.                   _loc3_ = Math.max(_loc3_,_loc9_.x + _loc9_.width);
  1024.                }
  1025.                if(!isNaN(_loc9_.height))
  1026.                {
  1027.                   _loc4_ = Math.max(_loc4_,_loc9_.y + _loc9_.height);
  1028.                }
  1029.             }
  1030.             _loc6_++;
  1031.          }
  1032.          _loc7_ = viewMetrics;
  1033.          _loc8_ = new Rectangle();
  1034.          _loc8_.left = _loc1_;
  1035.          _loc8_.top = _loc2_;
  1036.          _loc8_.right = _loc3_;
  1037.          _loc8_.bottom = _loc4_;
  1038.          if(mx_internal::usePadding)
  1039.          {
  1040.             _loc8_.right += getStyle("paddingRight");
  1041.             _loc8_.bottom += getStyle("paddingBottom");
  1042.          }
  1043.          return _loc8_;
  1044.       }
  1045.       
  1046.       mx_internal function get numRepeaters() : int
  1047.       {
  1048.          return !!mx_internal::childRepeaters ? int(mx_internal::childRepeaters.length) : 0;
  1049.       }
  1050.       
  1051.       public function get creationIndex() : int
  1052.       {
  1053.          return _creationIndex;
  1054.       }
  1055.       
  1056.       override mx_internal function childAdded(param1:DisplayObject) : void
  1057.       {
  1058.          var _loc2_:ChildExistenceChangedEvent = null;
  1059.          dispatchEvent(new Event("childrenChanged"));
  1060.          _loc2_ = new ChildExistenceChangedEvent(ChildExistenceChangedEvent.CHILD_ADD);
  1061.          _loc2_.relatedObject = param1;
  1062.          dispatchEvent(_loc2_);
  1063.          param1.dispatchEvent(new FlexEvent(FlexEvent.ADD));
  1064.          super.mx_internal::childAdded(param1);
  1065.       }
  1066.       
  1067.       public function set horizontalScrollPolicy(param1:String) : void
  1068.       {
  1069.          if(mx_internal::_horizontalScrollPolicy != param1)
  1070.          {
  1071.             mx_internal::_horizontalScrollPolicy = param1;
  1072.             invalidateDisplayList();
  1073.             dispatchEvent(new Event("horizontalScrollPolicyChanged"));
  1074.          }
  1075.       }
  1076.       
  1077.       override public function removeChildAt(param1:int) : DisplayObject
  1078.       {
  1079.          return removeChild(getChildAt(param1));
  1080.       }
  1081.       
  1082.       override mx_internal function fillOverlay(param1:UIComponent, param2:uint, param3:RoundedRectangle = null) : void
  1083.       {
  1084.          var _loc4_:EdgeMetrics = null;
  1085.          var _loc5_:Number = NaN;
  1086.          var _loc6_:Graphics = null;
  1087.          _loc4_ = viewMetrics;
  1088.          _loc5_ = 0;
  1089.          if(!param3)
  1090.          {
  1091.             param3 = new RoundedRectangle(_loc4_.left,_loc4_.top,unscaledWidth - _loc4_.right - _loc4_.left,unscaledHeight - _loc4_.bottom - _loc4_.top,_loc5_);
  1092.          }
  1093.          if(isNaN(param3.x) || isNaN(param3.y) || isNaN(param3.width) || isNaN(param3.height) || isNaN(param3.cornerRadius))
  1094.          {
  1095.             return;
  1096.          }
  1097.          _loc6_ = param1.graphics;
  1098.          _loc6_.clear();
  1099.          _loc6_.beginFill(param2);
  1100.          _loc6_.drawRoundRect(param3.x,param3.y,param3.width,param3.height,param3.cornerRadius * 2,param3.cornerRadius * 2);
  1101.          _loc6_.endFill();
  1102.       }
  1103.       
  1104.       public function createComponentsFromDescriptors(param1:Boolean = true) : void
  1105.       {
  1106.          var _loc2_:int = 0;
  1107.          var _loc3_:int = 0;
  1108.          var _loc4_:IFlexDisplayObject = null;
  1109.          numChildrenBefore = numChildren;
  1110.          mx_internal::createdComponents = [];
  1111.          _loc2_ = !!childDescriptors ? int(childDescriptors.length) : 0;
  1112.          _loc3_ = 0;
  1113.          while(_loc3_ < _loc2_)
  1114.          {
  1115.             _loc4_ = createComponentFromDescriptor(childDescriptors[_loc3_],param1);
  1116.             mx_internal::createdComponents.push(_loc4_);
  1117.             _loc3_++;
  1118.          }
  1119.          if(creationPolicy == ContainerCreationPolicy.QUEUED || creationPolicy == ContainerCreationPolicy.NONE)
  1120.          {
  1121.             UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = false;
  1122.          }
  1123.          mx_internal::numChildrenCreated = numChildren - numChildrenBefore;
  1124.          processedDescriptors = true;
  1125.       }
  1126.       
  1127.       override public function globalToContent(param1:Point) : Point
  1128.       {
  1129.          if(mx_internal::contentPane)
  1130.          {
  1131.             return mx_internal::contentPane.globalToLocal(param1);
  1132.          }
  1133.          return globalToLocal(param1);
  1134.       }
  1135.       
  1136.       override mx_internal function removingChild(param1:DisplayObject) : void
  1137.       {
  1138.          var _loc2_:ChildExistenceChangedEvent = null;
  1139.          super.mx_internal::removingChild(param1);
  1140.          param1.dispatchEvent(new FlexEvent(FlexEvent.REMOVE));
  1141.          _loc2_ = new ChildExistenceChangedEvent(ChildExistenceChangedEvent.CHILD_REMOVE);
  1142.          _loc2_.relatedObject = param1;
  1143.          dispatchEvent(_loc2_);
  1144.       }
  1145.       
  1146.       private function isBorderNeeded() : Boolean
  1147.       {
  1148.          var _loc1_:Object = null;
  1149.          _loc1_ = getStyle("borderStyle");
  1150.          if(_loc1_)
  1151.          {
  1152.             if(_loc1_ != "none" || _loc1_ == "none" && getStyle("mouseShield"))
  1153.             {
  1154.                return true;
  1155.             }
  1156.          }
  1157.          _loc1_ = getStyle("backgroundColor");
  1158.          if(_loc1_ !== null && _loc1_ !== "")
  1159.          {
  1160.             return true;
  1161.          }
  1162.          _loc1_ = getStyle("backgroundImage");
  1163.          return _loc1_ != null && _loc1_ != "";
  1164.       }
  1165.       
  1166.       mx_internal function rawChildren_removeChildAt(param1:int) : DisplayObject
  1167.       {
  1168.          var _loc2_:DisplayObject = null;
  1169.          _loc2_ = super.getChildAt(param1);
  1170.          super.mx_internal::removingChild(_loc2_);
  1171.          mx_internal::$removeChildAt(param1);
  1172.          super.mx_internal::childRemoved(_loc2_);
  1173.          if(_firstChildIndex < param1 && param1 < _firstChildIndex + mx_internal::_numChildren)
  1174.          {
  1175.             --mx_internal::_numChildren;
  1176.          }
  1177.          else if(mx_internal::_numChildren == 0 || param1 < _firstChildIndex)
  1178.          {
  1179.             --_firstChildIndex;
  1180.          }
  1181.          invalidateSize();
  1182.          invalidateDisplayList();
  1183.          dispatchEvent(new Event("childrenChanged"));
  1184.          return _loc2_;
  1185.       }
  1186.       
  1187.       [Bindable("verticalPageScrollSizeChanged")]
  1188.       public function get verticalPageScrollSize() : Number
  1189.       {
  1190.          return _verticalPageScrollSize;
  1191.       }
  1192.       
  1193.       override public function validateDisplayList() : void
  1194.       {
  1195.          var _loc1_:EdgeMetrics = null;
  1196.          var _loc2_:Number = NaN;
  1197.          var _loc3_:Number = NaN;
  1198.          var _loc4_:Object = null;
  1199.          var _loc5_:Number = NaN;
  1200.          var _loc6_:Number = NaN;
  1201.          var _loc7_:Number = NaN;
  1202.          if(_autoLayout || forceLayout)
  1203.          {
  1204.             mx_internal::doingLayout = true;
  1205.             super.validateDisplayList();
  1206.             mx_internal::doingLayout = false;
  1207.          }
  1208.          else
  1209.          {
  1210.             layoutChrome(unscaledWidth,unscaledHeight);
  1211.          }
  1212.          mx_internal::invalidateDisplayListFlag = true;
  1213.          if(createContentPaneAndScrollbarsIfNeeded())
  1214.          {
  1215.             if(_autoLayout || forceLayout)
  1216.             {
  1217.                mx_internal::doingLayout = true;
  1218.                super.validateDisplayList();
  1219.                mx_internal::doingLayout = false;
  1220.             }
  1221.             createContentPaneAndScrollbarsIfNeeded();
  1222.          }
  1223.          if(mx_internal::contentPane)
  1224.          {
  1225.             _loc1_ = viewMetrics;
  1226.             if(mx_internal::overlay)
  1227.             {
  1228.                mx_internal::overlay.x = 0;
  1229.                mx_internal::overlay.y = 0;
  1230.                mx_internal::overlay.width = unscaledWidth;
  1231.                mx_internal::overlay.height = unscaledHeight;
  1232.             }
  1233.             if(Boolean(horizontalScrollBar) || Boolean(verticalScrollBar))
  1234.             {
  1235.                if(Boolean(verticalScrollBar) && verticalScrollPolicy == ScrollPolicy.ON)
  1236.                {
  1237.                   _loc1_.right -= verticalScrollBar.minWidth;
  1238.                }
  1239.                if(Boolean(horizontalScrollBar) && horizontalScrollPolicy == ScrollPolicy.ON)
  1240.                {
  1241.                   _loc1_.bottom -= horizontalScrollBar.minHeight;
  1242.                }
  1243.                if(horizontalScrollBar)
  1244.                {
  1245.                   _loc2_ = unscaledWidth - _loc1_.left - _loc1_.right;
  1246.                   if(verticalScrollBar)
  1247.                   {
  1248.                      _loc2_ -= verticalScrollBar.minWidth;
  1249.                   }
  1250.                   horizontalScrollBar.setActualSize(_loc2_,horizontalScrollBar.minHeight);
  1251.                   horizontalScrollBar.move(_loc1_.left,unscaledHeight - _loc1_.bottom - horizontalScrollBar.minHeight);
  1252.                }
  1253.                if(verticalScrollBar)
  1254.                {
  1255.                   _loc3_ = unscaledHeight - _loc1_.top - _loc1_.bottom;
  1256.                   if(horizontalScrollBar)
  1257.                   {
  1258.                      _loc3_ -= horizontalScrollBar.minHeight;
  1259.                   }
  1260.                   verticalScrollBar.setActualSize(verticalScrollBar.minWidth,_loc3_);
  1261.                   verticalScrollBar.move(unscaledWidth - _loc1_.right - verticalScrollBar.minWidth,_loc1_.top);
  1262.                }
  1263.                if(whiteBox)
  1264.                {
  1265.                   whiteBox.x = verticalScrollBar.x;
  1266.                   whiteBox.y = horizontalScrollBar.y;
  1267.                }
  1268.             }
  1269.             mx_internal::contentPane.x = _loc1_.left;
  1270.             mx_internal::contentPane.y = _loc1_.top;
  1271.             if(focusPane)
  1272.             {
  1273.                focusPane.x = _loc1_.left;
  1274.                focusPane.y = _loc1_.top;
  1275.             }
  1276.             scrollChildren();
  1277.          }
  1278.          mx_internal::invalidateDisplayListFlag = false;
  1279.          if(mx_internal::blocker)
  1280.          {
  1281.             _loc1_ = viewMetrics;
  1282.             _loc4_ = enabled ? null : getStyle("backgroundDisabledColor");
  1283.             if(!_loc4_)
  1284.             {
  1285.                _loc4_ = getStyle("backgroundColor");
  1286.             }
  1287.             if(_loc4_ === null || isNaN(Number(_loc4_)))
  1288.             {
  1289.                _loc4_ = 16777215;
  1290.             }
  1291.             _loc5_ = getStyle("disabledOverlayAlpha");
  1292.             if(isNaN(_loc5_))
  1293.             {
  1294.                _loc5_ = 0.6;
  1295.             }
  1296.             mx_internal::blocker.x = _loc1_.left;
  1297.             mx_internal::blocker.y = _loc1_.top;
  1298.             _loc6_ = unscaledWidth - (_loc1_.left + _loc1_.right);
  1299.             _loc7_ = unscaledHeight - (_loc1_.top + _loc1_.bottom);
  1300.             mx_internal::blocker.graphics.clear();
  1301.             mx_internal::blocker.graphics.beginFill(uint(_loc4_),_loc5_);
  1302.             mx_internal::blocker.graphics.drawRect(0,0,_loc6_,_loc7_);
  1303.             mx_internal::blocker.graphics.endFill();
  1304.             rawChildren.setChildIndex(mx_internal::blocker,rawChildren.numChildren - 1);
  1305.          }
  1306.       }
  1307.       
  1308.       public function set horizontalLineScrollSize(param1:Number) : void
  1309.       {
  1310.          scrollPropertiesChanged = true;
  1311.          _horizontalLineScrollSize = param1;
  1312.          invalidateDisplayList();
  1313.          dispatchEvent(new Event("horizontalLineScrollSizeChanged"));
  1314.       }
  1315.       
  1316.       override public function contentToGlobal(param1:Point) : Point
  1317.       {
  1318.          if(mx_internal::contentPane)
  1319.          {
  1320.             return mx_internal::contentPane.localToGlobal(param1);
  1321.          }
  1322.          return localToGlobal(param1);
  1323.       }
  1324.       
  1325.       mx_internal function set forceClipping(param1:Boolean) : void
  1326.       {
  1327.          if(_clipContent)
  1328.          {
  1329.             if(param1)
  1330.             {
  1331.                ++_forceClippingCount;
  1332.             }
  1333.             else
  1334.             {
  1335.                --_forceClippingCount;
  1336.             }
  1337.             mx_internal::createContentPane();
  1338.             scrollChildren();
  1339.          }
  1340.       }
  1341.       
  1342.       [Bindable("horizontalPageScrollSizeChanged")]
  1343.       public function get horizontalPageScrollSize() : Number
  1344.       {
  1345.          return _horizontalPageScrollSize;
  1346.       }
  1347.       
  1348.       public function set defaultButton(param1:IFlexDisplayObject) : void
  1349.       {
  1350.          _defaultButton = param1;
  1351.          ContainerGlobals.focusedContainer = null;
  1352.       }
  1353.       
  1354.       private function hasChildMatchingDescriptor(param1:UIComponentDescriptor) : Boolean
  1355.       {
  1356.          var _loc2_:String = null;
  1357.          var _loc3_:int = 0;
  1358.          var _loc4_:int = 0;
  1359.          var _loc5_:IUIComponent = null;
  1360.          _loc2_ = param1.id;
  1361.          if(_loc2_ != null && document[_loc2_] == null)
  1362.          {
  1363.             return false;
  1364.          }
  1365.          _loc3_ = numChildren;
  1366.          _loc4_ = 0;
  1367.          while(_loc4_ < _loc3_)
  1368.          {
  1369.             _loc5_ = IUIComponent(getChildAt(_loc4_));
  1370.             if(_loc5_ is IDeferredInstantiationUIComponent && IDeferredInstantiationUIComponent(_loc5_).descriptor == param1)
  1371.             {
  1372.                return true;
  1373.             }
  1374.             _loc4_++;
  1375.          }
  1376.          if(mx_internal::childRepeaters)
  1377.          {
  1378.             _loc3_ = int(mx_internal::childRepeaters.length);
  1379.             _loc4_ = 0;
  1380.             while(_loc4_ < _loc3_)
  1381.             {
  1382.                if(IDeferredInstantiationUIComponent(mx_internal::childRepeaters[_loc4_]).descriptor == param1)
  1383.                {
  1384.                   return true;
  1385.                }
  1386.                _loc4_++;
  1387.             }
  1388.          }
  1389.          return false;
  1390.       }
  1391.       
  1392.       override protected function commitProperties() : void
  1393.       {
  1394.          var _loc1_:String = null;
  1395.          super.commitProperties();
  1396.          if(changedStyles)
  1397.          {
  1398.             _loc1_ = changedStyles == MULTIPLE_PROPERTIES ? null : changedStyles;
  1399.             super.notifyStyleChangeInChildren(_loc1_,true);
  1400.             changedStyles = null;
  1401.          }
  1402.          createOrDestroyBlocker();
  1403.       }
  1404.       
  1405.       override public function finishPrint(param1:Object, param2:IFlexDisplayObject) : void
  1406.       {
  1407.          if(param1)
  1408.          {
  1409.             mx_internal::contentPane.scrollRect = Rectangle(param1);
  1410.          }
  1411.          super.finishPrint(param1,param2);
  1412.       }
  1413.       
  1414.       public function get autoLayout() : Boolean
  1415.       {
  1416.          return _autoLayout;
  1417.       }
  1418.       
  1419.       public function get maxHorizontalScrollPosition() : Number
  1420.       {
  1421.          return !!horizontalScrollBar ? horizontalScrollBar.maxScrollPosition : Math.max(scrollableWidth - viewableWidth,0);
  1422.       }
  1423.       
  1424.       public function set creationPolicy(param1:String) : void
  1425.       {
  1426.          _creationPolicy = param1;
  1427.          mx_internal::setActualCreationPolicies(param1);
  1428.       }
  1429.       
  1430.       public function set verticalScrollPolicy(param1:String) : void
  1431.       {
  1432.          if(mx_internal::_verticalScrollPolicy != param1)
  1433.          {
  1434.             mx_internal::_verticalScrollPolicy = param1;
  1435.             invalidateDisplayList();
  1436.             dispatchEvent(new Event("verticalScrollPolicyChanged"));
  1437.          }
  1438.       }
  1439.       
  1440.       override public function prepareToPrint(param1:IFlexDisplayObject) : Object
  1441.       {
  1442.          var _loc2_:Rectangle = null;
  1443.          _loc2_ = Boolean(mx_internal::contentPane) && Boolean(mx_internal::contentPane.scrollRect) ? mx_internal::contentPane.scrollRect : null;
  1444.          if(_loc2_)
  1445.          {
  1446.             mx_internal::contentPane.scrollRect = null;
  1447.          }
  1448.          super.prepareToPrint(param1);
  1449.          return _loc2_;
  1450.       }
  1451.       
  1452.       public function set label(param1:String) : void
  1453.       {
  1454.          _label = param1;
  1455.          dispatchEvent(new Event("labelChanged"));
  1456.       }
  1457.       
  1458.       override protected function initializationComplete() : void
  1459.       {
  1460.       }
  1461.       
  1462.       override mx_internal function addingChild(param1:DisplayObject) : void
  1463.       {
  1464.          var _loc2_:IUIComponent = null;
  1465.          _loc2_ = IUIComponent(param1);
  1466.          super.mx_internal::addingChild(param1);
  1467.          invalidateSize();
  1468.          invalidateDisplayList();
  1469.          if(!mx_internal::contentPane)
  1470.          {
  1471.             if(mx_internal::_numChildren == 0)
  1472.             {
  1473.                _firstChildIndex = super.numChildren;
  1474.             }
  1475.             ++mx_internal::_numChildren;
  1476.          }
  1477.          if(Boolean(mx_internal::contentPane) && !autoLayout)
  1478.          {
  1479.             forceLayout = true;
  1480.             UIComponentGlobals.mx_internal::layoutManager.addEventListener("updateComplete",layoutCompleteHandler,false,0,true);
  1481.          }
  1482.       }
  1483.       
  1484.       mx_internal function setActualCreationPolicies(param1:String) : void
  1485.       {
  1486.          var _loc2_:String = null;
  1487.          var _loc3_:int = 0;
  1488.          var _loc4_:int = 0;
  1489.          var _loc5_:IFlexDisplayObject = null;
  1490.          var _loc6_:Container = null;
  1491.          actualCreationPolicy = param1;
  1492.          _loc2_ = param1;
  1493.          if(param1 == ContainerCreationPolicy.QUEUED)
  1494.          {
  1495.             _loc2_ = ContainerCreationPolicy.AUTO;
  1496.          }
  1497.          _loc3_ = numChildren;
  1498.          _loc4_ = 0;
  1499.          while(_loc4_ < _loc3_)
  1500.          {
  1501.             _loc5_ = IFlexDisplayObject(getChildAt(_loc4_));
  1502.             if(_loc5_ is Container)
  1503.             {
  1504.                _loc6_ = Container(_loc5_);
  1505.                if(_loc6_.creationPolicy == null)
  1506.                {
  1507.                   _loc6_.mx_internal::setActualCreationPolicies(_loc2_);
  1508.                }
  1509.             }
  1510.             _loc4_++;
  1511.          }
  1512.       }
  1513.       
  1514.       override public function set doubleClickEnabled(param1:Boolean) : void
  1515.       {
  1516.          var _loc2_:int = 0;
  1517.          var _loc3_:int = 0;
  1518.          var _loc4_:InteractiveObject = null;
  1519.          super.doubleClickEnabled = param1;
  1520.          if(mx_internal::contentPane)
  1521.          {
  1522.             _loc2_ = mx_internal::contentPane.numChildren;
  1523.             _loc3_ = 0;
  1524.             while(_loc3_ < _loc2_)
  1525.             {
  1526.                _loc4_ = mx_internal::contentPane.getChildAt(_loc3_) as InteractiveObject;
  1527.                if(_loc4_)
  1528.                {
  1529.                   _loc4_.doubleClickEnabled = param1;
  1530.                }
  1531.                _loc3_++;
  1532.             }
  1533.          }
  1534.       }
  1535.       
  1536.       override public function contains(param1:DisplayObject) : Boolean
  1537.       {
  1538.          if(mx_internal::contentPane)
  1539.          {
  1540.             return mx_internal::contentPane.contains(param1);
  1541.          }
  1542.          return super.contains(param1);
  1543.       }
  1544.       
  1545.       public function set clipContent(param1:Boolean) : void
  1546.       {
  1547.          if(_clipContent != param1)
  1548.          {
  1549.             _clipContent = param1;
  1550.             invalidateDisplayList();
  1551.          }
  1552.       }
  1553.       
  1554.       override public function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  1555.       {
  1556.          var _loc3_:int = 0;
  1557.          var _loc4_:int = 0;
  1558.          var _loc5_:ISimpleStyleClient = null;
  1559.          _loc3_ = super.numChildren;
  1560.          _loc4_ = 0;
  1561.          while(_loc4_ < _loc3_)
  1562.          {
  1563.             if(mx_internal::contentPane || _loc4_ < _firstChildIndex || _loc4_ >= _firstChildIndex + mx_internal::_numChildren)
  1564.             {
  1565.                _loc5_ = super.getChildAt(_loc4_) as ISimpleStyleClient;
  1566.                if(_loc5_)
  1567.                {
  1568.                   _loc5_.styleChanged(param1);
  1569.                   if(_loc5_ is IStyleClient)
  1570.                   {
  1571.                      IStyleClient(_loc5_).notifyStyleChangeInChildren(param1,param2);
  1572.                   }
  1573.                }
  1574.             }
  1575.             _loc4_++;
  1576.          }
  1577.          if(param2)
  1578.          {
  1579.             changedStyles = changedStyles != null || param1 == null ? MULTIPLE_PROPERTIES : param1;
  1580.             invalidateProperties();
  1581.          }
  1582.       }
  1583.       
  1584.       override public function get contentMouseX() : Number
  1585.       {
  1586.          if(mx_internal::contentPane)
  1587.          {
  1588.             return mx_internal::contentPane.mouseX;
  1589.          }
  1590.          return super.contentMouseX;
  1591.       }
  1592.       
  1593.       override public function get contentMouseY() : Number
  1594.       {
  1595.          if(mx_internal::contentPane)
  1596.          {
  1597.             return mx_internal::contentPane.mouseY;
  1598.          }
  1599.          return super.contentMouseY;
  1600.       }
  1601.       
  1602.       override public function validateSize(param1:Boolean = false) : void
  1603.       {
  1604.          var _loc2_:int = 0;
  1605.          var _loc3_:int = 0;
  1606.          var _loc4_:DisplayObject = null;
  1607.          if(autoLayout == false && forceLayout == false)
  1608.          {
  1609.             if(param1)
  1610.             {
  1611.                _loc2_ = super.numChildren;
  1612.                _loc3_ = 0;
  1613.                while(_loc3_ < _loc2_)
  1614.                {
  1615.                   _loc4_ = super.getChildAt(_loc3_);
  1616.                   if(_loc4_ is ILayoutManagerClient)
  1617.                   {
  1618.                      ILayoutManagerClient(_loc4_).validateSize(true);
  1619.                   }
  1620.                   _loc3_++;
  1621.                }
  1622.             }
  1623.             mx_internal::adjustSizesForScaleChanges();
  1624.          }
  1625.          else
  1626.          {
  1627.             super.validateSize(param1);
  1628.          }
  1629.       }
  1630.       
  1631.       override public function getChildAt(param1:int) : DisplayObject
  1632.       {
  1633.          if(mx_internal::contentPane)
  1634.          {
  1635.             return mx_internal::contentPane.getChildAt(param1);
  1636.          }
  1637.          return super.getChildAt(_firstChildIndex + param1);
  1638.       }
  1639.       
  1640.       protected function layoutChrome(param1:Number, param2:Number) : void
  1641.       {
  1642.          if(mx_internal::border)
  1643.          {
  1644.             updateBackgroundImageRect();
  1645.             mx_internal::border.move(0,0);
  1646.             mx_internal::border.setActualSize(param1,param2);
  1647.          }
  1648.       }
  1649.       
  1650.       override public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  1651.       {
  1652.          super.addEventListener(param1,param2,param3,param4,param5);
  1653.          if(param1 == MouseEvent.CLICK || param1 == MouseEvent.DOUBLE_CLICK || param1 == MouseEvent.MOUSE_DOWN || param1 == MouseEvent.MOUSE_MOVE || param1 == MouseEvent.MOUSE_OVER || param1 == MouseEvent.MOUSE_OUT || param1 == MouseEvent.MOUSE_UP || param1 == MouseEvent.MOUSE_WHEEL)
  1654.          {
  1655.             if(mouseEventReferenceCount < 2147483647 && mouseEventReferenceCount++ == 0)
  1656.             {
  1657.                setStyle("mouseShield",true);
  1658.                setStyle("mouseShieldChildren",true);
  1659.             }
  1660.          }
  1661.       }
  1662.       
  1663.       override protected function attachOverlay() : void
  1664.       {
  1665.          mx_internal::rawChildren_addChild(mx_internal::overlay);
  1666.       }
  1667.       
  1668.       override public function localToContent(param1:Point) : Point
  1669.       {
  1670.          if(!mx_internal::contentPane)
  1671.          {
  1672.             return param1;
  1673.          }
  1674.          param1 = localToGlobal(param1);
  1675.          return globalToContent(param1);
  1676.       }
  1677.       
  1678.       public function get rawChildren() : IChildList
  1679.       {
  1680.          if(!_rawChildren)
  1681.          {
  1682.             _rawChildren = new ContainerRawChildrenList(this);
  1683.          }
  1684.          return _rawChildren;
  1685.       }
  1686.       
  1687.       public function get viewMetrics() : EdgeMetrics
  1688.       {
  1689.          var _loc1_:EdgeMetrics = null;
  1690.          var _loc2_:Boolean = false;
  1691.          var _loc3_:Boolean = false;
  1692.          _loc1_ = borderMetrics;
  1693.          _loc2_ = verticalScrollBar != null && (mx_internal::doingLayout || verticalScrollPolicy == ScrollPolicy.ON);
  1694.          _loc3_ = horizontalScrollBar != null && (mx_internal::doingLayout || horizontalScrollPolicy == ScrollPolicy.ON);
  1695.          if(!_loc2_ && !_loc3_)
  1696.          {
  1697.             return _loc1_;
  1698.          }
  1699.          if(!_viewMetrics)
  1700.          {
  1701.             _viewMetrics = _loc1_.clone();
  1702.          }
  1703.          else
  1704.          {
  1705.             _viewMetrics.left = _loc1_.left;
  1706.             _viewMetrics.right = _loc1_.right;
  1707.             _viewMetrics.top = _loc1_.top;
  1708.             _viewMetrics.bottom = _loc1_.bottom;
  1709.          }
  1710.          if(_loc2_)
  1711.          {
  1712.             _viewMetrics.right += verticalScrollBar.minWidth;
  1713.          }
  1714.          if(_loc3_)
  1715.          {
  1716.             _viewMetrics.bottom += horizontalScrollBar.minHeight;
  1717.          }
  1718.          return _viewMetrics;
  1719.       }
  1720.       
  1721.       public function set creationIndex(param1:int) : void
  1722.       {
  1723.          _creationIndex = param1;
  1724.       }
  1725.       
  1726.       public function executeChildBindings(param1:Boolean) : void
  1727.       {
  1728.          var _loc2_:int = 0;
  1729.          var _loc3_:int = 0;
  1730.          var _loc4_:IUIComponent = null;
  1731.          _loc2_ = numChildren;
  1732.          _loc3_ = 0;
  1733.          while(_loc3_ < _loc2_)
  1734.          {
  1735.             _loc4_ = IUIComponent(getChildAt(_loc3_));
  1736.             if(_loc4_ is IDeferredInstantiationUIComponent)
  1737.             {
  1738.                IDeferredInstantiationUIComponent(_loc4_).executeBindings(param1);
  1739.             }
  1740.             _loc3_++;
  1741.          }
  1742.       }
  1743.       
  1744.       public function set verticalScrollBar(param1:ScrollBar) : void
  1745.       {
  1746.          _verticalScrollBar = param1;
  1747.       }
  1748.       
  1749.       public function get horizontalScrollBar() : ScrollBar
  1750.       {
  1751.          return _horizontalScrollBar;
  1752.       }
  1753.       
  1754.       private function createOrDestroyBlocker() : void
  1755.       {
  1756.          var _loc1_:DisplayObject = null;
  1757.          var _loc2_:ISystemManager = null;
  1758.          if(enabled)
  1759.          {
  1760.             if(mx_internal::blocker)
  1761.             {
  1762.                rawChildren.removeChild(mx_internal::blocker);
  1763.                mx_internal::blocker = null;
  1764.             }
  1765.          }
  1766.          else if(!mx_internal::blocker)
  1767.          {
  1768.             mx_internal::blocker = new FlexSprite();
  1769.             mx_internal::blocker.name = "blocker";
  1770.             mx_internal::blocker.mouseEnabled = true;
  1771.             rawChildren.addChild(mx_internal::blocker);
  1772.             mx_internal::blocker.addEventListener(MouseEvent.CLICK,blocker_clickHandler);
  1773.             _loc1_ = !!focusManager ? DisplayObject(focusManager.getFocus()) : null;
  1774.             while(_loc1_)
  1775.             {
  1776.                if(_loc1_ == this)
  1777.                {
  1778.                   _loc2_ = systemManager;
  1779.                   if(Boolean(_loc2_) && Boolean(_loc2_.stage))
  1780.                   {
  1781.                      _loc2_.stage.focus = null;
  1782.                   }
  1783.                   break;
  1784.                }
  1785.                _loc1_ = _loc1_.parent;
  1786.             }
  1787.          }
  1788.       }
  1789.       
  1790.       override public function set enabled(param1:Boolean) : void
  1791.       {
  1792.          super.enabled = param1;
  1793.          if(horizontalScrollBar)
  1794.          {
  1795.             horizontalScrollBar.enabled = param1;
  1796.          }
  1797.          if(verticalScrollBar)
  1798.          {
  1799.             verticalScrollBar.enabled = param1;
  1800.          }
  1801.          invalidateProperties();
  1802.       }
  1803.       
  1804.       override public function getChildByName(param1:String) : DisplayObject
  1805.       {
  1806.          var _loc2_:DisplayObject = null;
  1807.          var _loc3_:int = 0;
  1808.          if(mx_internal::contentPane)
  1809.          {
  1810.             return mx_internal::contentPane.getChildByName(param1);
  1811.          }
  1812.          _loc2_ = super.getChildByName(param1);
  1813.          if(!_loc2_)
  1814.          {
  1815.             return null;
  1816.          }
  1817.          _loc3_ = super.getChildIndex(_loc2_) - _firstChildIndex;
  1818.          if(_loc3_ < 0 || _loc3_ >= mx_internal::_numChildren)
  1819.          {
  1820.             return null;
  1821.          }
  1822.          return _loc2_;
  1823.       }
  1824.       
  1825.       override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  1826.       {
  1827.          mx_internal::addingChild(param1);
  1828.          if(mx_internal::contentPane)
  1829.          {
  1830.             mx_internal::contentPane.addChildAt(param1,param2);
  1831.          }
  1832.          else
  1833.          {
  1834.             mx_internal::$addChildAt(param1,_firstChildIndex + param2);
  1835.          }
  1836.          mx_internal::childAdded(param1);
  1837.          return param1;
  1838.       }
  1839.       
  1840.       override public function get baselinePosition() : Number
  1841.       {
  1842.          var _loc1_:IUIComponent = null;
  1843.          if(getStyle("verticalAlign") == "top" && numChildren > 0)
  1844.          {
  1845.             _loc1_ = getChildAt(0) as IUIComponent;
  1846.             if(_loc1_)
  1847.             {
  1848.                return _loc1_.y + _loc1_.baselinePosition;
  1849.             }
  1850.          }
  1851.          return super.baselinePosition;
  1852.       }
  1853.       
  1854.       private function blocker_clickHandler(param1:Event) : void
  1855.       {
  1856.          param1.stopPropagation();
  1857.       }
  1858.       
  1859.       public function get maxVerticalScrollPosition() : Number
  1860.       {
  1861.          return !!verticalScrollBar ? verticalScrollBar.maxScrollPosition : Math.max(scrollableHeight - viewableHeight,0);
  1862.       }
  1863.       
  1864.       public function set verticalPageScrollSize(param1:Number) : void
  1865.       {
  1866.          scrollPropertiesChanged = true;
  1867.          _verticalPageScrollSize = param1;
  1868.          invalidateDisplayList();
  1869.          dispatchEvent(new Event("verticalPageScrollSizeChanged"));
  1870.       }
  1871.       
  1872.       private function creationCompleteHandler(param1:FlexEvent) : void
  1873.       {
  1874.          --mx_internal::numChildrenCreated;
  1875.          if(mx_internal::numChildrenCreated <= 0)
  1876.          {
  1877.             dispatchEvent(new FlexEvent("childrenCreationComplete"));
  1878.          }
  1879.       }
  1880.       
  1881.       override public function contentToLocal(param1:Point) : Point
  1882.       {
  1883.          if(!mx_internal::contentPane)
  1884.          {
  1885.             return param1;
  1886.          }
  1887.          param1 = contentToGlobal(param1);
  1888.          return globalToLocal(param1);
  1889.       }
  1890.       
  1891.       override public function removeChild(param1:DisplayObject) : DisplayObject
  1892.       {
  1893.          mx_internal::removingChild(param1);
  1894.          if(mx_internal::contentPane)
  1895.          {
  1896.             mx_internal::contentPane.removeChild(param1);
  1897.          }
  1898.          else
  1899.          {
  1900.             mx_internal::$removeChild(param1);
  1901.          }
  1902.          mx_internal::childRemoved(param1);
  1903.          return param1;
  1904.       }
  1905.       
  1906.       private function dispatchScrollEvent(param1:String, param2:Number, param3:Number, param4:String) : void
  1907.       {
  1908.          var _loc5_:ScrollEvent = null;
  1909.          _loc5_ = new ScrollEvent(ScrollEvent.SCROLL);
  1910.          _loc5_.direction = param1;
  1911.          _loc5_.position = param3;
  1912.          _loc5_.delta = param3 - param2;
  1913.          _loc5_.detail = param4;
  1914.          dispatchEvent(_loc5_);
  1915.       }
  1916.       
  1917.       [Bindable("labelChanged")]
  1918.       public function get label() : String
  1919.       {
  1920.          return _label;
  1921.       }
  1922.       
  1923.       mx_internal function setDocumentDescriptor(param1:UIComponentDescriptor) : void
  1924.       {
  1925.          if(processedDescriptors)
  1926.          {
  1927.             return;
  1928.          }
  1929.          if(Boolean(mx_internal::_documentDescriptor) && Boolean(mx_internal::_documentDescriptor.properties.childDescriptors))
  1930.          {
  1931.             if(param1.properties.childDescriptors)
  1932.             {
  1933.                throw new Error(resourceMultipleChildSets_ClassAndSubclass);
  1934.             }
  1935.          }
  1936.          else
  1937.          {
  1938.             mx_internal::_documentDescriptor = param1;
  1939.             mx_internal::_documentDescriptor.document = this;
  1940.          }
  1941.       }
  1942.       
  1943.       override public function setChildIndex(param1:DisplayObject, param2:int) : void
  1944.       {
  1945.          var _loc3_:int = 0;
  1946.          var _loc4_:int = 0;
  1947.          var _loc5_:int = 0;
  1948.          var _loc6_:IndexChangedEvent = null;
  1949.          _loc4_ = _loc3_;
  1950.          _loc5_ = param2;
  1951.          if(mx_internal::contentPane)
  1952.          {
  1953.             mx_internal::contentPane.setChildIndex(param1,param2);
  1954.             if(_autoLayout || forceLayout)
  1955.             {
  1956.                invalidateDisplayList();
  1957.             }
  1958.          }
  1959.          else
  1960.          {
  1961.             _loc3_ = super.getChildIndex(param1);
  1962.             param2 += _firstChildIndex;
  1963.             if(param2 == _loc3_)
  1964.             {
  1965.                return;
  1966.             }
  1967.             super.setChildIndex(param1,param2);
  1968.             invalidateDisplayList();
  1969.             _loc4_ = _loc3_ - _firstChildIndex;
  1970.             _loc5_ = param2 - _firstChildIndex;
  1971.          }
  1972.          _loc6_ = new IndexChangedEvent(IndexChangedEvent.CHILD_INDEX_CHANGE);
  1973.          _loc6_.relatedObject = param1;
  1974.          _loc6_.oldIndex = _loc4_;
  1975.          _loc6_.newIndex = _loc5_;
  1976.          dispatchEvent(_loc6_);
  1977.          dispatchEvent(new Event("childrenChanged"));
  1978.       }
  1979.       
  1980.       override public function regenerateStyleCache(param1:Boolean) : void
  1981.       {
  1982.          var _loc2_:int = 0;
  1983.          var _loc3_:int = 0;
  1984.          var _loc4_:DisplayObject = null;
  1985.          super.regenerateStyleCache(param1);
  1986.          if(mx_internal::contentPane)
  1987.          {
  1988.             _loc2_ = mx_internal::contentPane.numChildren;
  1989.             _loc3_ = 0;
  1990.             while(_loc3_ < _loc2_)
  1991.             {
  1992.                _loc4_ = getChildAt(_loc3_);
  1993.                if(param1 && _loc4_ is UIComponent)
  1994.                {
  1995.                   if(UIComponent(_loc4_).inheritingStyles != UIComponent.mx_internal::STYLE_UNINITIALIZED)
  1996.                   {
  1997.                      UIComponent(_loc4_).regenerateStyleCache(param1);
  1998.                   }
  1999.                }
  2000.                else if(_loc4_ is UITextField && Boolean(UITextField(_loc4_).inheritingStyles))
  2001.                {
  2002.                   StyleProtoChain.initTextField(UITextField(_loc4_));
  2003.                }
  2004.                _loc3_++;
  2005.             }
  2006.          }
  2007.       }
  2008.       
  2009.       override protected function createChildren() : void
  2010.       {
  2011.          var _loc1_:Application = null;
  2012.          super.createChildren();
  2013.          createBorder();
  2014.          createOrDestroyScrollbars(horizontalScrollPolicy == ScrollPolicy.ON,verticalScrollPolicy == ScrollPolicy.ON,horizontalScrollPolicy == ScrollPolicy.ON || verticalScrollPolicy == ScrollPolicy.ON);
  2015.          if(creationPolicy != null)
  2016.          {
  2017.             actualCreationPolicy = creationPolicy;
  2018.          }
  2019.          else if(parent is Container)
  2020.          {
  2021.             if(Container(parent).actualCreationPolicy == ContainerCreationPolicy.QUEUED)
  2022.             {
  2023.                actualCreationPolicy = ContainerCreationPolicy.AUTO;
  2024.             }
  2025.             else
  2026.             {
  2027.                actualCreationPolicy = Container(parent).actualCreationPolicy;
  2028.             }
  2029.          }
  2030.          if(actualCreationPolicy == ContainerCreationPolicy.NONE)
  2031.          {
  2032.             actualCreationPolicy = ContainerCreationPolicy.AUTO;
  2033.          }
  2034.          else if(actualCreationPolicy == ContainerCreationPolicy.QUEUED)
  2035.          {
  2036.             _loc1_ = !!parentApplication ? Application(parentApplication) : Application(Application.application);
  2037.             _loc1_.addToCreationQueue(this,creationIndex,null,this);
  2038.          }
  2039.          else if(recursionFlag)
  2040.          {
  2041.             createComponentsFromDescriptors();
  2042.          }
  2043.          if(autoLayout == false)
  2044.          {
  2045.             forceLayout = true;
  2046.          }
  2047.          UIComponentGlobals.mx_internal::layoutManager.addEventListener("updateComplete",layoutCompleteHandler,false,0,true);
  2048.       }
  2049.       
  2050.       mx_internal function set numChildrenCreated(param1:int) : void
  2051.       {
  2052.          _numChildrenCreated = param1;
  2053.       }
  2054.       
  2055.       public function get borderMetrics() : EdgeMetrics
  2056.       {
  2057.          return Boolean(mx_internal::border) && mx_internal::border is RectangularBorder ? RectangularBorder(mx_internal::border).borderMetrics : EdgeMetrics.EMPTY;
  2058.       }
  2059.       
  2060.       public function get clipContent() : Boolean
  2061.       {
  2062.          return _clipContent;
  2063.       }
  2064.       
  2065.       mx_internal function rawChildren_setChildIndex(param1:DisplayObject, param2:int) : void
  2066.       {
  2067.          var _loc3_:int = 0;
  2068.          _loc3_ = super.getChildIndex(param1);
  2069.          super.setChildIndex(param1,param2);
  2070.          if(_loc3_ < _firstChildIndex && param2 >= _firstChildIndex)
  2071.          {
  2072.             --_firstChildIndex;
  2073.          }
  2074.          else if(_loc3_ >= _firstChildIndex && param2 <= _firstChildIndex)
  2075.          {
  2076.             ++_firstChildIndex;
  2077.          }
  2078.          dispatchEvent(new Event("childrenChanged"));
  2079.       }
  2080.       
  2081.       mx_internal function rawChildren_getChildAt(param1:int) : DisplayObject
  2082.       {
  2083.          return super.getChildAt(param1);
  2084.       }
  2085.       
  2086.       public function get verticalScrollBar() : ScrollBar
  2087.       {
  2088.          return _verticalScrollBar;
  2089.       }
  2090.       
  2091.       public function get viewMetricsAndPadding() : EdgeMetrics
  2092.       {
  2093.          var _loc1_:EdgeMetrics = null;
  2094.          var _loc2_:EdgeMetrics = null;
  2095.          if(_viewMetricsAndPadding && (!horizontalScrollBar || horizontalScrollPolicy == ScrollPolicy.ON) && (!verticalScrollBar || verticalScrollPolicy == ScrollPolicy.ON))
  2096.          {
  2097.             return _viewMetricsAndPadding;
  2098.          }
  2099.          if(!_viewMetricsAndPadding)
  2100.          {
  2101.             _viewMetricsAndPadding = new EdgeMetrics();
  2102.          }
  2103.          _loc1_ = _viewMetricsAndPadding;
  2104.          _loc2_ = viewMetrics;
  2105.          _loc1_.left = _loc2_.left + getStyle("paddingLeft");
  2106.          _loc1_.right = _loc2_.right + getStyle("paddingRight");
  2107.          _loc1_.top = _loc2_.top + getStyle("paddingTop");
  2108.          _loc1_.bottom = _loc2_.bottom + getStyle("paddingBottom");
  2109.          return _loc1_;
  2110.       }
  2111.       
  2112.       public function set horizontalPageScrollSize(param1:Number) : void
  2113.       {
  2114.          scrollPropertiesChanged = true;
  2115.          _horizontalPageScrollSize = param1;
  2116.          invalidateDisplayList();
  2117.          dispatchEvent(new Event("horizontalPageScrollSizeChanged"));
  2118.       }
  2119.       
  2120.       private function layoutCompleteHandler(param1:Event) : void
  2121.       {
  2122.          var _loc2_:Boolean = false;
  2123.          UIComponentGlobals.mx_internal::layoutManager.removeEventListener("updateComplete",layoutCompleteHandler);
  2124.          forceLayout = false;
  2125.          _loc2_ = false;
  2126.          if(!isNaN(horizontalScrollPositionPending))
  2127.          {
  2128.             if(horizontalScrollPositionPending < 0)
  2129.             {
  2130.                horizontalScrollPositionPending = 0;
  2131.             }
  2132.             else if(horizontalScrollPositionPending > maxHorizontalScrollPosition)
  2133.             {
  2134.                horizontalScrollPositionPending = maxHorizontalScrollPosition;
  2135.             }
  2136.             if(Boolean(horizontalScrollBar) && horizontalScrollBar.scrollPosition != horizontalScrollPositionPending)
  2137.             {
  2138.                _horizontalScrollPosition = horizontalScrollPositionPending;
  2139.                horizontalScrollBar.scrollPosition = horizontalScrollPositionPending;
  2140.                _loc2_ = true;
  2141.             }
  2142.             horizontalScrollPositionPending = NaN;
  2143.          }
  2144.          if(!isNaN(verticalScrollPositionPending))
  2145.          {
  2146.             if(verticalScrollPositionPending < 0)
  2147.             {
  2148.                verticalScrollPositionPending = 0;
  2149.             }
  2150.             else if(verticalScrollPositionPending > maxVerticalScrollPosition)
  2151.             {
  2152.                verticalScrollPositionPending = maxVerticalScrollPosition;
  2153.             }
  2154.             if(Boolean(verticalScrollBar) && verticalScrollBar.scrollPosition != verticalScrollPositionPending)
  2155.             {
  2156.                _verticalScrollPosition = verticalScrollPositionPending;
  2157.                verticalScrollBar.scrollPosition = verticalScrollPositionPending;
  2158.                _loc2_ = true;
  2159.             }
  2160.             verticalScrollPositionPending = NaN;
  2161.          }
  2162.          if(_loc2_)
  2163.          {
  2164.             scrollChildren();
  2165.          }
  2166.       }
  2167.       
  2168.       override public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  2169.       {
  2170.          super.removeEventListener(param1,param2,param3);
  2171.          if(param1 == MouseEvent.CLICK || param1 == MouseEvent.DOUBLE_CLICK || param1 == MouseEvent.MOUSE_DOWN || param1 == MouseEvent.MOUSE_MOVE || param1 == MouseEvent.MOUSE_OVER || param1 == MouseEvent.MOUSE_OUT || param1 == MouseEvent.MOUSE_UP || param1 == MouseEvent.MOUSE_WHEEL)
  2172.          {
  2173.             if(mouseEventReferenceCount > 0 && --mouseEventReferenceCount == 0)
  2174.             {
  2175.                setStyle("mouseShield",false);
  2176.                setStyle("mouseShieldChildren",false);
  2177.             }
  2178.          }
  2179.       }
  2180.       
  2181.       public function set autoLayout(param1:Boolean) : void
  2182.       {
  2183.          var _loc2_:IInvalidating = null;
  2184.          _autoLayout = param1;
  2185.          if(param1)
  2186.          {
  2187.             invalidateSize();
  2188.             invalidateDisplayList();
  2189.             _loc2_ = parent as IInvalidating;
  2190.             if(_loc2_)
  2191.             {
  2192.                _loc2_.invalidateSize();
  2193.                _loc2_.invalidateDisplayList();
  2194.             }
  2195.          }
  2196.       }
  2197.       
  2198.       mx_internal function rawChildren_getChildByName(param1:String) : DisplayObject
  2199.       {
  2200.          return super.getChildByName(param1);
  2201.       }
  2202.       
  2203.       mx_internal function get numChildrenCreated() : int
  2204.       {
  2205.          return _numChildrenCreated;
  2206.       }
  2207.       
  2208.       override public function initialize() : void
  2209.       {
  2210.          var _loc1_:* = undefined;
  2211.          if(isDocument && mx_internal::documentDescriptor && !processedDescriptors)
  2212.          {
  2213.             _loc1_ = mx_internal::documentDescriptor.properties;
  2214.             if(_loc1_ && Boolean(_loc1_.childDescriptors))
  2215.             {
  2216.                if(_childDescriptors)
  2217.                {
  2218.                   throw new Error(resourceMultipleChildSets_ClassAndInstance);
  2219.                }
  2220.                _childDescriptors = _loc1_.childDescriptors;
  2221.             }
  2222.          }
  2223.          super.initialize();
  2224.       }
  2225.       
  2226.       mx_internal function rawChildren_addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  2227.       {
  2228.          if(_firstChildIndex < param2 && param2 < _firstChildIndex + mx_internal::$numChildren + 1)
  2229.          {
  2230.             ++mx_internal::_numChildren;
  2231.          }
  2232.          else if(param2 <= _firstChildIndex)
  2233.          {
  2234.             ++_firstChildIndex;
  2235.          }
  2236.          super.mx_internal::addingChild(param1);
  2237.          mx_internal::$addChildAt(param1,param2);
  2238.          super.mx_internal::childAdded(param1);
  2239.          dispatchEvent(new Event("childrenChanged"));
  2240.          return param1;
  2241.       }
  2242.       
  2243.       public function set data(param1:Object) : void
  2244.       {
  2245.          _data = param1;
  2246.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  2247.          invalidateDisplayList();
  2248.       }
  2249.       
  2250.       private function createScrollbarsIfNeeded(param1:Rectangle) : Boolean
  2251.       {
  2252.          var _loc2_:Number = NaN;
  2253.          var _loc3_:Number = NaN;
  2254.          var _loc4_:Number = NaN;
  2255.          var _loc5_:Number = NaN;
  2256.          var _loc6_:Boolean = false;
  2257.          var _loc7_:EdgeMetrics = null;
  2258.          var _loc8_:* = false;
  2259.          var _loc9_:* = false;
  2260.          var _loc10_:Boolean = false;
  2261.          var _loc11_:Boolean = false;
  2262.          _loc2_ = param1.right;
  2263.          _loc3_ = param1.bottom;
  2264.          _loc4_ = unscaledWidth;
  2265.          _loc5_ = unscaledHeight;
  2266.          _loc6_ = param1.left < 0 || param1.top < 0;
  2267.          _loc7_ = viewMetrics;
  2268.          if(scaleX != 1)
  2269.          {
  2270.             _loc4_ += 1 / Math.abs(scaleX);
  2271.          }
  2272.          if(scaleY != 1)
  2273.          {
  2274.             _loc5_ += 1 / Math.abs(scaleY);
  2275.          }
  2276.          _loc4_ = Math.floor(_loc4_);
  2277.          _loc5_ = Math.floor(_loc5_);
  2278.          _loc2_ = Math.floor(_loc2_);
  2279.          _loc3_ = Math.floor(_loc3_);
  2280.          if(Boolean(horizontalScrollBar) && horizontalScrollPolicy != ScrollPolicy.ON)
  2281.          {
  2282.             _loc5_ -= horizontalScrollBar.minHeight;
  2283.          }
  2284.          if(Boolean(verticalScrollBar) && verticalScrollPolicy != ScrollPolicy.ON)
  2285.          {
  2286.             _loc4_ -= verticalScrollBar.minWidth;
  2287.          }
  2288.          _loc4_ -= _loc7_.left + _loc7_.right;
  2289.          _loc5_ -= _loc7_.top + _loc7_.bottom;
  2290.          _loc8_ = horizontalScrollPolicy == ScrollPolicy.ON;
  2291.          _loc9_ = verticalScrollPolicy == ScrollPolicy.ON;
  2292.          _loc10_ = _loc8_ || _loc9_ || _loc6_ || mx_internal::overlay != null || _loc7_.left > 0 || _loc7_.top > 0;
  2293.          if(_loc4_ < _loc2_)
  2294.          {
  2295.             _loc10_ = true;
  2296.             if(horizontalScrollPolicy == ScrollPolicy.AUTO && unscaledHeight - _loc7_.top - _loc7_.bottom >= 18 && unscaledWidth - _loc7_.left - _loc7_.right >= 32)
  2297.             {
  2298.                _loc8_ = true;
  2299.             }
  2300.          }
  2301.          if(_loc5_ < _loc3_)
  2302.          {
  2303.             _loc10_ = true;
  2304.             if(verticalScrollPolicy == ScrollPolicy.AUTO && unscaledWidth - _loc7_.left - _loc7_.right >= 18 && unscaledHeight - _loc7_.top - _loc7_.bottom >= 32)
  2305.             {
  2306.                _loc9_ = true;
  2307.             }
  2308.          }
  2309.          if(_loc8_ && _loc9_ && horizontalScrollPolicy == ScrollPolicy.AUTO && verticalScrollPolicy == ScrollPolicy.AUTO && horizontalScrollBar && verticalScrollBar && _loc4_ + verticalScrollBar.minWidth >= _loc2_ && _loc5_ + horizontalScrollBar.minHeight >= _loc3_)
  2310.          {
  2311.             _loc8_ = _loc9_ = false;
  2312.          }
  2313.          else if(_loc8_ && !_loc9_ && verticalScrollBar && horizontalScrollPolicy == ScrollPolicy.AUTO && _loc4_ + verticalScrollBar.minWidth >= _loc2_)
  2314.          {
  2315.             _loc8_ = false;
  2316.          }
  2317.          _loc11_ = createOrDestroyScrollbars(_loc8_,_loc9_,_loc10_);
  2318.          if(scrollableWidth != _loc2_ || viewableWidth != _loc4_ || _loc11_)
  2319.          {
  2320.             if(horizontalScrollBar)
  2321.             {
  2322.                horizontalScrollBar.setScrollProperties(_loc4_ - borderMetrics.right,0,_loc2_ - _loc4_,horizontalPageScrollSize);
  2323.                scrollPositionChanged = true;
  2324.             }
  2325.             viewableWidth = _loc4_;
  2326.             scrollableWidth = _loc2_;
  2327.          }
  2328.          if(scrollableHeight != _loc3_ || viewableHeight != _loc5_ || _loc11_)
  2329.          {
  2330.             if(verticalScrollBar)
  2331.             {
  2332.                verticalScrollBar.setScrollProperties(_loc5_ - borderMetrics.bottom,0,_loc3_ - _loc5_,verticalPageScrollSize);
  2333.                scrollPositionChanged = true;
  2334.             }
  2335.             viewableHeight = _loc5_;
  2336.             scrollableHeight = _loc3_;
  2337.          }
  2338.          return _loc11_;
  2339.       }
  2340.       
  2341.       [Bindable("childrenChanged")]
  2342.       public function getChildren() : Array
  2343.       {
  2344.          var _loc1_:Array = null;
  2345.          var _loc2_:int = 0;
  2346.          var _loc3_:int = 0;
  2347.          _loc1_ = [];
  2348.          _loc2_ = numChildren;
  2349.          _loc3_ = 0;
  2350.          while(_loc3_ < _loc2_)
  2351.          {
  2352.             _loc1_.push(getChildAt(_loc3_));
  2353.             _loc3_++;
  2354.          }
  2355.          return _loc1_;
  2356.       }
  2357.       
  2358.       public function removeAllChildren() : void
  2359.       {
  2360.          while(numChildren > 0)
  2361.          {
  2362.             removeChildAt(0);
  2363.          }
  2364.       }
  2365.       
  2366.       override mx_internal function childRemoved(param1:DisplayObject) : void
  2367.       {
  2368.          super.mx_internal::childRemoved(param1);
  2369.          invalidateSize();
  2370.          invalidateDisplayList();
  2371.          if(!mx_internal::contentPane)
  2372.          {
  2373.             --mx_internal::_numChildren;
  2374.             if(mx_internal::_numChildren == 0)
  2375.             {
  2376.                _firstChildIndex = super.numChildren;
  2377.             }
  2378.          }
  2379.          if(Boolean(mx_internal::contentPane) && !autoLayout)
  2380.          {
  2381.             forceLayout = true;
  2382.             UIComponentGlobals.mx_internal::layoutManager.addEventListener("updateComplete",layoutCompleteHandler,false,0,true);
  2383.          }
  2384.          dispatchEvent(new Event("childrenChanged"));
  2385.       }
  2386.       
  2387.       override public function get numChildren() : int
  2388.       {
  2389.          return !!mx_internal::contentPane ? mx_internal::contentPane.numChildren : mx_internal::_numChildren;
  2390.       }
  2391.       
  2392.       [Bindable("dataChange")]
  2393.       public function get data() : Object
  2394.       {
  2395.          return _data;
  2396.       }
  2397.       
  2398.       override public function styleChanged(param1:String) : void
  2399.       {
  2400.          var _loc2_:Boolean = false;
  2401.          var _loc3_:String = null;
  2402.          var _loc4_:String = null;
  2403.          _loc2_ = param1 == null || param1 == "styleName";
  2404.          if(_loc2_ || StyleManager.isSizeInvalidatingStyle(param1))
  2405.          {
  2406.             invalidateDisplayList();
  2407.          }
  2408.          if(_loc2_ || param1 == "borderSkin")
  2409.          {
  2410.             if(mx_internal::border)
  2411.             {
  2412.                rawChildren.removeChild(DisplayObject(mx_internal::border));
  2413.                mx_internal::border = null;
  2414.                createBorder();
  2415.             }
  2416.          }
  2417.          if(_loc2_ || param1 == "borderStyle" || param1 == "backgroundColor" || param1 == "backgroundImage" || param1 == "mouseShield" || param1 == "mouseShieldChildren")
  2418.          {
  2419.             createBorder();
  2420.          }
  2421.          super.styleChanged(param1);
  2422.          if(_loc2_ || StyleManager.isSizeInvalidatingStyle(param1))
  2423.          {
  2424.             mx_internal::invalidateViewMetricsAndPadding();
  2425.          }
  2426.          if(_loc2_ || param1 == "horizontalScrollBarStyleName")
  2427.          {
  2428.             if(Boolean(horizontalScrollBar) && horizontalScrollBar is ISimpleStyleClient)
  2429.             {
  2430.                _loc3_ = getStyle("horizontalScrollBarStyleName");
  2431.                ISimpleStyleClient(horizontalScrollBar).styleName = _loc3_;
  2432.             }
  2433.          }
  2434.          if(_loc2_ || param1 == "verticalScrollBarStyleName")
  2435.          {
  2436.             if(Boolean(verticalScrollBar) && verticalScrollBar is ISimpleStyleClient)
  2437.             {
  2438.                _loc4_ = getStyle("verticalScrollBarStyleName");
  2439.                ISimpleStyleClient(verticalScrollBar).styleName = _loc4_;
  2440.             }
  2441.          }
  2442.       }
  2443.       
  2444.       private function createContentPaneAndScrollbarsIfNeeded() : Boolean
  2445.       {
  2446.          var _loc1_:Rectangle = null;
  2447.          var _loc2_:Boolean = false;
  2448.          if(_clipContent)
  2449.          {
  2450.             _loc1_ = mx_internal::getScrollableRect();
  2451.             _loc2_ = createScrollbarsIfNeeded(_loc1_);
  2452.             if(mx_internal::border)
  2453.             {
  2454.                updateBackgroundImageRect();
  2455.             }
  2456.             return _loc2_;
  2457.          }
  2458.          _loc2_ = createOrDestroyScrollbars(false,false,false);
  2459.          _loc1_ = mx_internal::getScrollableRect();
  2460.          scrollableWidth = _loc1_.right;
  2461.          scrollableHeight = _loc1_.bottom;
  2462.          if(_loc2_ && Boolean(mx_internal::border))
  2463.          {
  2464.             updateBackgroundImageRect();
  2465.          }
  2466.          return _loc2_;
  2467.       }
  2468.       
  2469.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  2470.       {
  2471.          var _loc3_:Object = null;
  2472.          var _loc4_:Number = NaN;
  2473.          super.updateDisplayList(param1,param2);
  2474.          layoutChrome(param1,param2);
  2475.          if(scrollPositionChanged)
  2476.          {
  2477.             if(_horizontalScrollPosition < 0)
  2478.             {
  2479.                _horizontalScrollPosition = 0;
  2480.             }
  2481.             else if(_horizontalScrollPosition > maxHorizontalScrollPosition)
  2482.             {
  2483.                _horizontalScrollPosition = maxHorizontalScrollPosition;
  2484.             }
  2485.             if(Boolean(horizontalScrollBar) && horizontalScrollBar.scrollPosition != _horizontalScrollPosition)
  2486.             {
  2487.                horizontalScrollBar.scrollPosition = _horizontalScrollPosition;
  2488.             }
  2489.             if(_verticalScrollPosition < 0)
  2490.             {
  2491.                _verticalScrollPosition = 0;
  2492.             }
  2493.             else if(_verticalScrollPosition > maxVerticalScrollPosition)
  2494.             {
  2495.                _verticalScrollPosition = maxVerticalScrollPosition;
  2496.             }
  2497.             if(Boolean(verticalScrollBar) && verticalScrollBar.scrollPosition != _verticalScrollPosition)
  2498.             {
  2499.                verticalScrollBar.scrollPosition = _verticalScrollPosition;
  2500.             }
  2501.             scrollChildren();
  2502.             scrollPositionChanged = false;
  2503.          }
  2504.          if(scrollPropertiesChanged)
  2505.          {
  2506.             if(horizontalScrollBar)
  2507.             {
  2508.                horizontalScrollBar.lineScrollSize = horizontalLineScrollSize;
  2509.                horizontalScrollBar.pageScrollSize = horizontalPageScrollSize;
  2510.             }
  2511.             if(verticalScrollBar)
  2512.             {
  2513.                verticalScrollBar.lineScrollSize = verticalLineScrollSize;
  2514.                verticalScrollBar.pageScrollSize = verticalPageScrollSize;
  2515.             }
  2516.             scrollPropertiesChanged = false;
  2517.          }
  2518.          if(Boolean(mx_internal::contentPane) && Boolean(mx_internal::contentPane.scrollRect))
  2519.          {
  2520.             _loc3_ = enabled ? null : getStyle("backgroundDisabledColor");
  2521.             if(!_loc3_)
  2522.             {
  2523.                _loc3_ = getStyle("backgroundColor");
  2524.             }
  2525.             _loc4_ = getStyle("backgroundAlpha");
  2526.             if(!_clipContent || isNaN(Number(_loc3_)) || _loc3_ === "" || !(Boolean(horizontalScrollBar) || Boolean(verticalScrollBar)) && !cacheAsBitmap)
  2527.             {
  2528.                _loc3_ = null;
  2529.             }
  2530.             else if(getStyle("backgroundImage") || getStyle("background"))
  2531.             {
  2532.                _loc3_ = null;
  2533.             }
  2534.             else if(_loc4_ != 1)
  2535.             {
  2536.                _loc3_ = null;
  2537.             }
  2538.             mx_internal::contentPane.opaqueBackground = _loc3_;
  2539.             mx_internal::contentPane.cacheAsBitmap = _loc3_ != null;
  2540.          }
  2541.       }
  2542.       
  2543.       mx_internal function rawChildren_addChild(param1:DisplayObject) : DisplayObject
  2544.       {
  2545.          if(mx_internal::_numChildren == 0)
  2546.          {
  2547.             ++_firstChildIndex;
  2548.          }
  2549.          super.mx_internal::addingChild(param1);
  2550.          mx_internal::$addChild(param1);
  2551.          super.mx_internal::childAdded(param1);
  2552.          dispatchEvent(new Event("childrenChanged"));
  2553.          return param1;
  2554.       }
  2555.    }
  2556. }
  2557.  
  2558.